argparse.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
# Danial Behzadi <dani.behzi@ubuntu.com>, 2025
# Rafael Fontenelle <rffontenelle@gmail.com>, 2025
# Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026
# arman mohebali <armanmohebali@outlook.com>, 2026
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-10-23 04:16+0000\n"
"PO-Revision-Date: 2026-09-21 13:27+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:`!argparse` --- Parser for command-line options, arguments and subcommands"
msgstr ":mod:`!argparse` --- پارسر برای گزینه‌ها، آرگومان‌ها و زیرفرمان‌های خط فرمان"

msgid "**Source code:** :source:`Lib/argparse.py`"
msgstr "**کد منبع:** :source:`Lib/argparse.py`"

msgid "While :mod:`!argparse` is the default recommended standard library module for implementing basic command line applications, authors with more exacting requirements for exactly how their command line applications behave may find it doesn't provide the necessary level of control. Refer to :ref:`choosing-an-argument-parser` for alternatives to consider when ``argparse`` doesn't support behaviors that the application requires (such as entirely disabling support for interspersed options and positional arguments, or accepting option parameter values that start with ``-`` even when they correspond to another defined option)."
msgstr "در حالی که :mod:`!argparse` به‌طور پیش‌فرض به‌عنوان ماژول کتابخانه استاندارد برای پیاده‌سازی برنامه‌های پایه خط فرمان توصیه می‌شود، نویسندگانی که الزامات دقیق‌تری درباره نحوه دقیق رفتار برنامه‌های خط فرمان خود دارند، ممکن است دریابند که این ماژول سطح کنترل لازم را فراهم نمی‌کند. برای جایگزین‌های قابل بررسی در مواردی که ``argparse`` از رفتارهای مورد نیاز برنامه پشتیبانی نمی‌کند، به :ref:`choosing-an-argument-parser` مراجعه کنید (مانند غیرفعال کردن کامل پشتیبانی از درهم‌آمیختن گزینه‌ها و آرگومان‌های جایگاهی، یا پذیرفتن مقادیر پارامتر گزینه‌ها که با ``-`` شروع می‌شوند، حتی زمانی که با گزینه تعریف‌شده دیگری مطابقت دارند)."

msgid "Tutorial"
msgstr "آموزش"

msgid "This page contains the API reference information. For a more gentle introduction to Python command-line parsing, have a look at the :ref:`argparse tutorial <argparse-tutorial>`."
msgstr "این صفحه حاوی اطلاعات مرجع API است. برای آشنایی ملایم‌تر با تجزیه‌ی خط فرمان در پایتون، به :ref:`آموزش argparse <argparse-tutorial>` نگاهی بیندازید."

msgid "The :mod:`!argparse` module makes it easy to write user-friendly command-line interfaces. The program defines what arguments it requires, and :mod:`!argparse` will figure out how to parse those out of :data:`sys.argv`.  The :mod:`!argparse` module also automatically generates help and usage messages.  The module will also issue errors when users give the program invalid arguments."
msgstr "ماژول :mod:`!argparse` نوشتن رابط‌های خط فرمان کاربرپسند را آسان می‌کند. برنامه آرگومان‌هایی را که نیاز دارد تعریف می‌کند، و :mod:`!argparse` نحوه‌ی تجزیه‌ی آن‌ها از :data:`sys.argv` را تشخیص می‌دهد. ماژول :mod:`!argparse` همچنین به‌طور خودکار پیام‌های راهنما و کاربرد را تولید می‌کند. این ماژول همچنین زمانی که کاربران آرگومان‌های نامعتبر به برنامه بدهند، خطا نشان می‌دهد."

msgid "The :mod:`!argparse` module's support for command-line interfaces is built around an instance of :class:`argparse.ArgumentParser`.  It is a container for argument specifications and has options that apply to the parser as whole::"
msgstr "پشتیبانی ماژول :mod:`!argparse` از رابط‌های خط فرمان بر پایه‌ی نمونه‌ای از :class:`argparse.ArgumentParser` ساخته شده است. این کلاس ظرفی برای مشخصات آرگومان‌ها است و گزینه‌هایی دارد که به پارسر به‌عنوان یک کل اعمال می‌شوند::"

msgid ""
"parser = argparse.ArgumentParser(\n"
"                    prog='ProgramName',\n"
"                    description='What the program does',\n"
"                    epilog='Text at the bottom of help')"
msgstr ""
"parser = argparse.ArgumentParser(\n"
"                    prog='ProgramName',\n"
"                    description='What the program does',\n"
"                    epilog='Text at the bottom of help')"

msgid "The :meth:`ArgumentParser.add_argument` method attaches individual argument specifications to the parser.  It supports positional arguments, options that accept values, and on/off flags::"
msgstr "متد :meth:`ArgumentParser.add_argument` مشخصات آرگومان‌ها را به‌صورت جداگانه به پارسر اضافه می‌کند. این متد از آرگومان‌های جایگاهی، گزینه‌هایی که مقدار می‌پذیرند و پرچم‌های روشن/خاموش پشتیبانی می‌کند::"

msgid ""
"parser.add_argument('filename')           # positional argument\n"
"parser.add_argument('-c', '--count')      # option that takes a value\n"
"parser.add_argument('-v', '--verbose',\n"
"                    action='store_true')  # on/off flag"
msgstr ""
"parser.add_argument('filename')           # positional argument\n"
"parser.add_argument('-c', '--count')      # option that takes a value\n"
"parser.add_argument('-v', '--verbose',\n"
"                    action='store_true')  # on/off flag"

msgid "The :meth:`ArgumentParser.parse_args` method runs the parser and places the extracted data in a :class:`argparse.Namespace` object::"
msgstr "متد :meth:`ArgumentParser.parse_args` پارسر را اجرا می‌کند و داده‌های استخراج‌شده را در یک شیء :class:`argparse.Namespace` قرار می‌دهد::"

msgid ""
"args = parser.parse_args()\n"
"print(args.filename, args.count, args.verbose)"
msgstr ""
"args = parser.parse_args()\n"
"print(args.filename, args.count, args.verbose)"

msgid "If you're looking for a guide about how to upgrade :mod:`optparse` code to :mod:`!argparse`, see :ref:`Upgrading Optparse Code <upgrading-optparse-code>`."
msgstr "اگر به دنبال راهنمایی درباره چگونگی ارتقای کد :mod:`optparse` به :mod:`!argparse` هستید، :ref:`ارتقای کد Optparse <upgrading-optparse-code>` را ببینید."

msgid "ArgumentParser objects"
msgstr "اشیای ArgumentParser"

msgid "Create a new :class:`ArgumentParser` object. All parameters should be passed as keyword arguments. Each parameter has its own more detailed description below, but in short they are:"
msgstr "یک شیء :class:`ArgumentParser` جدید ایجاد کنید. همه پارامترها باید به‌صورت آرگومان‌های کلیدواژه‌ای ارسال شوند. هر پارامتر توضیح مفصل‌تری در زیر دارد، اما به‌طور خلاصه آن‌ها عبارتند از:"

msgid "prog_ - The name of the program (default: generated from the ``__main__`` module attributes and ``sys.argv[0]``)"
msgstr "prog_ - نام برنامه (پیش‌فرض: از ویژگی‌های ماژول ``__main__`` و ``sys.argv[0]`` تولید می‌شود)"

msgid "usage_ - The string describing the program usage (default: generated from arguments added to parser)"
msgstr "usage_ - رشته‌ای که کاربرد برنامه را توصیف می‌کند (پیش‌فرض: از آرگومان‌های اضافه‌شده به پارسر تولید می‌شود)"

msgid "description_ - Text to display before the argument help (by default, no text)"
msgstr "description_ - متن برای نمایش پیش از راهنمای آرگومان (به‌طور پیش‌فرض، بدون متن)"

msgid "epilog_ - Text to display after the argument help (by default, no text)"
msgstr "epilog_ - متنی که پس از راهنمای آرگومان نمایش داده می‌شود (به‌طور پیش‌فرض، بدون متن)"

msgid "parents_ - A list of :class:`ArgumentParser` objects whose arguments should also be included"
msgstr "parents_ - فهرستی از اشیای :class:`ArgumentParser` که آرگومان‌های آن‌ها نیز باید گنجانده شوند"

msgid "formatter_class_ - A class for customizing the help output"
msgstr "formatter_class_ - کلاسی برای سفارشی‌سازی خروجی راهنما"

msgid "prefix_chars_ - The set of characters that prefix optional arguments (default: '-')"
msgstr "prefix_chars_ - مجموعه‌ای از نویسه‌ها که پیشوند آرگومان‌های اختیاری را تشکیل می‌دهند (پیش‌فرض: '-')"

msgid "fromfile_prefix_chars_ - The set of characters that prefix files from which additional arguments should be read (default: ``None``)"
msgstr "fromfile_prefix_chars_ - مجموعه‌ای از نویسه‌ها که پیشوند پرونده‌هایی هستند که آرگومان‌های اضافی باید از آن‌ها خوانده شوند (پیش‌فرض: ``None``)"

msgid "argument_default_ - The global default value for arguments (default: ``None``)"
msgstr "argument_default_ - مقدار پیش‌فرض سراسری برای آرگومان‌ها (پیش‌فرض: ``None``)"

msgid "conflict_handler_ - The strategy for resolving conflicting optionals (usually unnecessary)"
msgstr "conflict_handler_ - راهبرد رفع تعارض گزینه‌های اختیاری (معمولاً غیرضروری)"

msgid "add_help_ - Add a ``-h/--help`` option to the parser (default: ``True``)"
msgstr "add_help_ - افزودن گزینه ``-h/--help`` به پارسر (پیش‌فرض: ``True``)"

msgid "allow_abbrev_ - Allows long options to be abbreviated if the abbreviation is unambiguous (default: ``True``)"
msgstr "allow_abbrev_ - اجازه می‌دهد گزینه‌های بلند مخفف شوند، مشروط بر اینکه مخفف بدون ابهام باشد (پیش‌فرض: ``True``)"

msgid "exit_on_error_ - Determines whether or not :class:`!ArgumentParser` exits with error info when an error occurs. (default: ``True``)"
msgstr "exit_on_error_ - تعیین می‌کند که آیا :class:`!ArgumentParser` هنگام بروز خطا همراه با اطلاعات خطا خارج می‌شود یا خیر. (پیش‌فرض: ``True``)"

msgid "suggest_on_error_ - Enables suggestions for mistyped argument choices and subparser names (default: ``True``)"
msgstr "suggest_on_error_ - پیشنهادها را برای انتخاب‌های آرگومان تایپ‌شده‌ی اشتباه و نام‌های زیرپارسر فعال می‌کند (پیش‌فرض: ``True``)"

msgid "color_ - Allow color output (default: ``True``)"
msgstr "color_ - اجازه دادن به خروجی رنگی (پیش‌فرض: ``True``)"

msgid "*allow_abbrev* parameter was added."
msgstr "پارامتر *allow_abbrev* افزوده شد."

msgid "In previous versions, *allow_abbrev* also disabled grouping of short flags such as ``-vv`` to mean ``-v -v``."
msgstr "در نسخه‌های پیشین، *allow_abbrev* گروه‌بندی پرچم‌های کوتاه مانند ``-vv`` به معنای ``-v -v`` را نیز غیرفعال می‌کرد."

msgid "*exit_on_error* parameter was added."
msgstr "پارامتر *exit_on_error* اضافه شد."

msgid "*suggest_on_error* and *color* parameters were added."
msgstr "پارامترهای *suggest_on_error* و *color* افزوده شدند."

msgid "*suggest_on_error* default changed to ``True``."
msgstr "مقدار پیش‌فرض *suggest_on_error* به ``True`` تغییر یافت."

msgid "The following sections describe how each of these are used."
msgstr "بخش‌های زیر چگونگی استفاده از هر یک از این موارد را شرح می‌دهند."

msgid "prog"
msgstr "prog"

msgid "By default, :class:`ArgumentParser` calculates the name of the program to display in help messages depending on the way the Python interpreter was run:"
msgstr "به‌طور پیش‌فرض، :class:`ArgumentParser` نام برنامه را برای نمایش در پیام‌های راهنما، بسته به شیوه‌ای که مفسر پایتون اجرا شده است، محاسبه می‌کند:"

msgid "The :func:`base name <os.path.basename>` of ``sys.argv[0]`` if a file was passed as argument."
msgstr ":func:`نام پایه <os.path.basename>` برای ``sys.argv[0]``، اگر پرونده‌ای به‌عنوان آرگومان داده شده باشد."

msgid "The Python interpreter name followed by ``sys.argv[0]`` if a directory or a zipfile was passed as argument."
msgstr "نام مفسر پایتون که پس از آن ``sys.argv[0]`` می‌آید، در صورتی که یک پوشه یا یک پرونده زیپ به‌عنوان آرگومان داده شده باشد."

msgid "The Python interpreter name followed by ``-m`` followed by the module or package name if the :option:`-m` option was used."
msgstr "نام مفسر پایتون، به‌دنبالِ ``-m`` و سپس نام ماژول یا بسته، در صورتی که گزینه‌ی :option:`-m` استفاده شده باشد."

msgid "This default is almost always desirable because it will make the help messages match the string that was used to invoke the program on the command line. However, to change this default behavior, another value can be supplied using the ``prog=`` argument to :class:`ArgumentParser`::"
msgstr "این پیش‌فرض تقریباً همیشه مطلوب است، زیرا باعث می‌شود پیام‌های راهنما با رشته‌ای که برنامه با آن در خط فرمان فراخوانی شده است مطابقت داشته باشند. با این حال، برای تغییر این رفتار پیش‌فرض، می‌توان مقدار دیگری را با استفاده از آرگومان ``prog=`` برای :class:`ArgumentParser`:: ارائه کرد:"

msgid ""
">>> parser = argparse.ArgumentParser(prog='myprogram')\n"
">>> parser.print_help()\n"
"usage: myprogram [-h]\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='myprogram')\n"
">>> parser.print_help()\n"
"usage: myprogram [-h]\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit"

msgid "Note that the program name, whether determined from ``sys.argv[0]``, from the ``__main__`` module attributes or from the ``prog=`` argument, is available to help messages using the ``%(prog)s`` format specifier."
msgstr "توجه داشته باشید که نام برنامه، چه از ``sys.argv[0]``، چه از ویژگی‌های ماژول ``__main__`` و چه از آرگومان ``prog=`` تعیین شده باشد، در پیام‌های راهنما از طریق مشخص‌کننده‌ی قالب ``%(prog)s`` در دسترس است."

msgid ""
">>> parser = argparse.ArgumentParser(prog='myprogram')\n"
">>> parser.add_argument('--foo', help='foo of the %(prog)s program')\n"
">>> parser.print_help()\n"
"usage: myprogram [-h] [--foo FOO]\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" --foo FOO   foo of the myprogram program"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='myprogram')\n"
">>> parser.add_argument('--foo', help='foo of the %(prog)s program')\n"
">>> parser.print_help()\n"
"usage: myprogram [-h] [--foo FOO]\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" --foo FOO   foo of the myprogram program"

msgid "The default ``prog`` value now reflects how ``__main__`` was actually executed, rather than always being ``os.path.basename(sys.argv[0])``."
msgstr "مقدار پیش‌فرض ``prog`` اکنون نشان می‌دهد که ``__main__`` واقعاً چگونه اجرا شده است، به‌جای آنکه همیشه ``os.path.basename(sys.argv[0])`` باشد."

msgid "usage"
msgstr "استفاده"

msgid "By default, :class:`ArgumentParser` calculates the usage message from the arguments it contains. The default message can be overridden with the ``usage=`` keyword argument::"
msgstr "به‌طور پیش‌فرض، :class:`ArgumentParser` پیام استفاده را بر اساس آرگومان‌های خود محاسبه می‌کند. پیام پیش‌فرض را می‌توان با آرگومان کلیدواژه‌ای ``usage=`` بازنویسی کرد::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', usage='%(prog)s [options]')\n"
">>> parser.add_argument('--foo', nargs='?', help='foo help')\n"
">>> parser.add_argument('bar', nargs='+', help='bar help')\n"
">>> parser.print_help()\n"
"usage: PROG [options]\n"
"\n"
"positional arguments:\n"
" bar          bar help\n"
"\n"
"options:\n"
" -h, --help   show this help message and exit\n"
" --foo [FOO]  foo help"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG', usage='%(prog)s [options]')\n"
">>> parser.add_argument('--foo', nargs='?', help='foo help')\n"
">>> parser.add_argument('bar', nargs='+', help='bar help')\n"
">>> parser.print_help()\n"
"usage: PROG [options]\n"
"\n"
"positional arguments:\n"
" bar          bar help\n"
"\n"
"options:\n"
" -h, --help   show this help message and exit\n"
" --foo [FOO]  foo help"

msgid "The ``%(prog)s`` format specifier is available to fill in the program name in your usage messages."
msgstr "مشخص‌کننده قالب ``%(prog)s`` برای جایگذاری نام برنامه در پیام‌های کاربرد شما در دسترس است."

msgid "When a custom usage message is specified for the main parser, you may also want to consider passing  the ``prog`` argument to :meth:`~ArgumentParser.add_subparsers` or the ``prog`` and the ``usage`` arguments to :meth:`~_SubParsersAction.add_parser`, to ensure consistent command prefixes and usage information across subparsers."
msgstr "هنگامی که پیام کاربرد سفارشی برای پارسر اصلی تعیین می‌شود، ممکن است بخواهید برای اطمینان از سازگاری پیشوندهای فرمان و اطلاعات کاربرد در میان پارسرهای فرعی، ارسال آرگومان ``prog`` به :meth:`~ArgumentParser.add_subparsers` یا آرگومان‌های ``prog`` و ``usage`` به :meth:`~_SubParsersAction.add_parser` را نیز در نظر بگیرید."

msgid "description"
msgstr "توضیحات"

msgid "Most calls to the :class:`ArgumentParser` constructor will use the ``description=`` keyword argument.  This argument gives a brief description of what the program does and how it works.  In help messages, the description is displayed between the command-line usage string and the help messages for the various arguments."
msgstr "در بیشتر فراخوانی‌های سازنده‌ی :class:`ArgumentParser`، از آرگومان کلیدواژه‌ای ``description=`` استفاده می‌شود. این آرگومان شرح مختصری از آنچه برنامه انجام می‌دهد و چگونگی کار آن ارائه می‌دهد. در پیام‌های راهنما، شرح بین رشته‌ی کاربرد خط فرمان و پیام‌های راهنمای آرگومان‌های مختلف نمایش داده می‌شود."

msgid "By default, the description will be line-wrapped so that it fits within the given space.  To change this behavior, see the formatter_class_ argument."
msgstr "به‌طور پیش‌فرض، سطرهای شرح شکسته می‌شوند تا در فضای داده‌شده بگنجند. برای تغییر این رفتار، آرگومان formatter_class_ را ببینید."

msgid "epilog"
msgstr "epilog"

msgid "Some programs like to display additional description of the program after the description of the arguments.  Such text can be specified using the ``epilog=`` argument to :class:`ArgumentParser`::"
msgstr "برخی برنامه‌ها تمایل دارند توضیحات تکمیلی برنامه را پس از توضیح آرگومان‌ها نمایش دهند. چنین متنی را می‌توان با استفاده از آرگومان ``epilog=`` برای :class:`ArgumentParser` مشخص کرد::"

msgid ""
">>> parser = argparse.ArgumentParser(\n"
"...     description='A foo that bars',\n"
"...     epilog=\"And that's how you'd foo a bar\")\n"
">>> parser.print_help()\n"
"usage: argparse.py [-h]\n"
"\n"
"A foo that bars\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
"\n"
"And that's how you'd foo a bar"
msgstr ""
">>> parser = argparse.ArgumentParser(\n"
"...     description='A foo that bars',\n"
"...     epilog=\"And that's how you'd foo a bar\")\n"
">>> parser.print_help()\n"
"usage: argparse.py [-h]\n"
"\n"
"A foo that bars\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
"\n"
"And that's how you'd foo a bar"

msgid "As with the description_ argument, the ``epilog=`` text is by default line-wrapped, but this behavior can be adjusted with the formatter_class_ argument to :class:`ArgumentParser`."
msgstr "همانند آرگومان description_، متن ``epilog=`` به‌طور پیش‌فرض در عرض خط شکسته می‌شود، اما این رفتار را می‌توان با آرگومان formatter_class_ برای :class:`ArgumentParser` تنظیم کرد."

msgid "parents"
msgstr "والدین"

msgid "Sometimes, several parsers share a common set of arguments. Rather than repeating the definitions of these arguments, a single parser with all the shared arguments and passed to ``parents=`` argument to :class:`ArgumentParser` can be used.  The ``parents=`` argument takes a list of :class:`ArgumentParser` objects, collects all the positional and optional actions from them, and adds these actions to the :class:`ArgumentParser` object being constructed::"
msgstr "گاهی چند پارسر مجموعه‌ای مشترک از آرگومان‌ها دارند. به‌جای تکرار تعاریف این آرگومان‌ها، می‌توان از یک پارسر واحد استفاده کرد که همه‌ی آرگومان‌های مشترک را دارد و به‌عنوان مقدار آرگومان ``parents=`` به :class:`ArgumentParser` ارسال می‌شود. آرگومان ``parents=`` فهرستی از اشیاء :class:`ArgumentParser` را می‌پذیرد، همه‌ی کنش‌های جایگاهی و اختیاری (actions) را از آن‌ها جمع‌آوری می‌کند و این کنش‌ها را به شیء :class:`ArgumentParser` که در حال ساخت است اضافه می‌کند::"

msgid ""
">>> parent_parser = argparse.ArgumentParser(add_help=False)\n"
">>> parent_parser.add_argument('--parent', type=int)\n"
"\n"
">>> foo_parser = argparse.ArgumentParser(parents=[parent_parser])\n"
">>> foo_parser.add_argument('foo')\n"
">>> foo_parser.parse_args(['--parent', '2', 'XXX'])\n"
"Namespace(foo='XXX', parent=2)\n"
"\n"
">>> bar_parser = argparse.ArgumentParser(parents=[parent_parser])\n"
">>> bar_parser.add_argument('--bar')\n"
">>> bar_parser.parse_args(['--bar', 'YYY'])\n"
"Namespace(bar='YYY', parent=None)"
msgstr ""
">>> parent_parser = argparse.ArgumentParser(add_help=False)\n"
">>> parent_parser.add_argument('--parent', type=int)\n"
"\n"
">>> foo_parser = argparse.ArgumentParser(parents=[parent_parser])\n"
">>> foo_parser.add_argument('foo')\n"
">>> foo_parser.parse_args(['--parent', '2', 'XXX'])\n"
"Namespace(foo='XXX', parent=2)\n"
"\n"
">>> bar_parser = argparse.ArgumentParser(parents=[parent_parser])\n"
">>> bar_parser.add_argument('--bar')\n"
">>> bar_parser.parse_args(['--bar', 'YYY'])\n"
"Namespace(bar='YYY', parent=None)"

msgid "Note that most parent parsers will specify ``add_help=False``.  Otherwise, the :class:`ArgumentParser` will see two ``-h/--help`` options (one in the parent and one in the child) and raise an error."
msgstr "توجه داشته باشید که بیشتر پارسرهای والد ``add_help=False`` را تعیین می‌کنند. در غیر این صورت، :class:`ArgumentParser` دو گزینه ``-h/--help`` (یکی در والد و دیگری در فرزند) را می‌بیند و خطایی پرتاب می‌کند."

msgid "You must fully initialize the parsers before passing them via ``parents=``. If you change the parent parsers after the child parser, those changes will not be reflected in the child."
msgstr "شما باید پارسرها را پیش از انتقال آن‌ها از طریق ``parents=`` به‌طور کامل مقداردهی اولیه کنید. اگر پارسرهای والد را پس از پارسر فرزند تغییر دهید، آن تغییرات در فرزند بازتاب نخواهند یافت."

msgid "formatter_class"
msgstr "formatter_class"

msgid ":class:`ArgumentParser` objects allow the help formatting to be customized by specifying an alternate formatting class.  Currently, there are four such classes:"
msgstr "اشیای :class:`ArgumentParser` امکان سفارشی‌سازی قالب‌بندی راهنما را با مشخص کردن یک کلاس قالب‌بندی جایگزین فراهم می‌کنند. در حال حاضر، چهار کلاس از این دست وجود دارد:"

msgid ":class:`RawDescriptionHelpFormatter` and :class:`RawTextHelpFormatter` give more control over how textual descriptions are displayed. By default, :class:`ArgumentParser` objects line-wrap the description_ and epilog_ texts in command-line help messages::"
msgstr ":class:`RawDescriptionHelpFormatter` و :class:`RawTextHelpFormatter` کنترل بیشتری بر چگونگی نمایش توضیحات متنی فراهم می‌کنند. به‌طور پیش‌فرض، اشیاء :class:`ArgumentParser` متن‌های description_ و epilog_ را در پیام‌های راهنمای خط فرمان با شکستن سطرها قالب‌بندی می‌کنند::"

msgid ""
">>> parser = argparse.ArgumentParser(\n"
"...     prog='PROG',\n"
"...     description='''this description\n"
"...         was indented weird\n"
"...             but that is okay''',\n"
"...     epilog='''\n"
"...             likewise for this epilog whose whitespace will\n"
"...         be cleaned up and whose words will be wrapped\n"
"...         across a couple lines''')\n"
">>> parser.print_help()\n"
"usage: PROG [-h]\n"
"\n"
"this description was indented weird but that is okay\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
"\n"
"likewise for this epilog whose whitespace will be cleaned up and whose words\n"
"will be wrapped across a couple lines"
msgstr ""
">>> parser = argparse.ArgumentParser(\n"
"...     prog='PROG',\n"
"...     description='''this description\n"
"...         was indented weird\n"
"...             but that is okay''',\n"
"...     epilog='''\n"
"...             likewise for this epilog whose whitespace will\n"
"...         be cleaned up and whose words will be wrapped\n"
"...         across a couple lines''')\n"
">>> parser.print_help()\n"
"usage: PROG [-h]\n"
"\n"
"this description was indented weird but that is okay\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
"\n"
"likewise for this epilog whose whitespace will be cleaned up and whose words\n"
"will be wrapped across a couple lines"

msgid "Passing :class:`RawDescriptionHelpFormatter` as ``formatter_class=`` indicates that description_ and epilog_ are already correctly formatted and should not be line-wrapped::"
msgstr "ارسال :class:`RawDescriptionHelpFormatter` به‌عنوان ``formatter_class=`` نشان می‌دهد که description_ و epilog_ از قبل به‌درستی قالب‌بندی شده‌اند و نباید سطرهای آن‌ها شکسته شوند::"

msgid ""
">>> parser = argparse.ArgumentParser(\n"
"...     prog='PROG',\n"
"...     formatter_class=argparse.RawDescriptionHelpFormatter,\n"
"...     description=textwrap.dedent('''\\\n"
"...         Please do not mess up this text!\n"
"...         --------------------------------\n"
"...             I have indented it\n"
"...             exactly the way\n"
"...             I want it\n"
"...         '''))\n"
">>> parser.print_help()\n"
"usage: PROG [-h]\n"
"\n"
"Please do not mess up this text!\n"
"--------------------------------\n"
"   I have indented it\n"
"   exactly the way\n"
"   I want it\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit"
msgstr ""
">>> parser = argparse.ArgumentParser(\n"
"...     prog='PROG',\n"
"...     formatter_class=argparse.RawDescriptionHelpFormatter,\n"
"...     description=textwrap.dedent('''\\\n"
"...         Please do not mess up this text!\n"
"...         --------------------------------\n"
"...             I have indented it\n"
"...             exactly the way\n"
"...             I want it\n"
"...         '''))\n"
">>> parser.print_help()\n"
"usage: PROG [-h]\n"
"\n"
"Please do not mess up this text!\n"
"--------------------------------\n"
"   I have indented it\n"
"   exactly the way\n"
"   I want it\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit"

msgid ":class:`RawTextHelpFormatter` maintains whitespace for all sorts of help text, including argument descriptions. However, multiple newlines are replaced with one. If you wish to preserve multiple blank lines, add spaces between the newlines."
msgstr ":class:`RawTextHelpFormatter` فضای سفید را برای همه‌ی انواع متن‌های راهنما، از جمله توضیحات آرگومان‌ها حفظ می‌کند. با این حال، چندین خط جدید با یک خط جدید جایگزین می‌شوند. اگر می‌خواهید چندین خط خالی حفظ شوند، بین سطرهای جدید فاصله اضافه کنید."

msgid ":class:`ArgumentDefaultsHelpFormatter` automatically adds information about default values to each of the argument help messages::"
msgstr ":class:`ArgumentDefaultsHelpFormatter` به‌طور خودکار اطلاعات مربوط به مقادیر پیش‌فرض را به هر یک از پیام‌های راهنمای آرگومان اضافه می‌کند::"

msgid ""
">>> parser = argparse.ArgumentParser(\n"
"...     prog='PROG',\n"
"...     formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n"
">>> parser.add_argument('--foo', type=int, default=42, help='FOO!')\n"
">>> parser.add_argument('bar', nargs='*', default=[1, 2, 3], help='BAR!')\n"
">>> parser.print_help()\n"
"usage: PROG [-h] [--foo FOO] [bar ...]\n"
"\n"
"positional arguments:\n"
" bar         BAR! (default: [1, 2, 3])\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" --foo FOO   FOO! (default: 42)"
msgstr ""
">>> parser = argparse.ArgumentParser(\n"
"...     prog='PROG',\n"
"...     formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n"
">>> parser.add_argument('--foo', type=int, default=42, help='FOO!')\n"
">>> parser.add_argument('bar', nargs='*', default=[1, 2, 3], help='BAR!')\n"
">>> parser.print_help()\n"
"usage: PROG [-h] [--foo FOO] [bar ...]\n"
"\n"
"positional arguments:\n"
" bar         BAR! (default: [1, 2, 3])\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" --foo FOO   FOO! (default: 42)"

msgid ":class:`MetavarTypeHelpFormatter` uses the name of the type_ argument for each argument as the display name for its values (rather than using the dest_ as the regular formatter does)::"
msgstr ":class:`MetavarTypeHelpFormatter` از نام آرگومان type_ برای هر آرگومان به‌عنوان نام نمایشی برای مقدارهای آن استفاده می‌کند (به‌جای استفاده از dest_ آن‌گونه که قالب‌بند معمولی انجام می‌دهد)::"

msgid ""
">>> parser = argparse.ArgumentParser(\n"
"...     prog='PROG',\n"
"...     formatter_class=argparse.MetavarTypeHelpFormatter)\n"
">>> parser.add_argument('--foo', type=int)\n"
">>> parser.add_argument('bar', type=float)\n"
">>> parser.print_help()\n"
"usage: PROG [-h] [--foo int] float\n"
"\n"
"positional arguments:\n"
"  float\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"  --foo int"
msgstr ""
">>> parser = argparse.ArgumentParser(\n"
"...     prog='PROG',\n"
"...     formatter_class=argparse.MetavarTypeHelpFormatter)\n"
">>> parser.add_argument('--foo', type=int)\n"
">>> parser.add_argument('bar', type=float)\n"
">>> parser.print_help()\n"
"usage: PROG [-h] [--foo int] float\n"
"\n"
"positional arguments:\n"
"  float\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"  --foo int"

msgid "prefix_chars"
msgstr "prefix_chars"

msgid "Most command-line options will use ``-`` as the prefix, e.g. ``-f/--foo``. Parsers that need to support different or additional prefix characters, e.g. for options like ``+f`` or ``/foo``, may specify them using the ``prefix_chars=`` argument to the :class:`ArgumentParser` constructor::"
msgstr "بیشتر گزینه‌های خط فرمان از ``-`` به‌عنوان پیشوند استفاده می‌کنند، برای مثال ``-f/--foo``. پارسرهایی که نیاز به پشتیبانی از نویسه‌های پیشوند متفاوت یا اضافی دارند، برای مثال برای گزینه‌هایی مانند ``+f`` یا ``/foo``، می‌توانند آن‌ها را با استفاده از آرگومان ``prefix_chars=`` در سازنده‌ی :class:`ArgumentParser` مشخص کنند::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='-+')\n"
">>> parser.add_argument('+f')\n"
">>> parser.add_argument('++bar')\n"
">>> parser.parse_args('+f X ++bar Y'.split())\n"
"Namespace(bar='Y', f='X')"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='-+')\n"
">>> parser.add_argument('+f')\n"
">>> parser.add_argument('++bar')\n"
">>> parser.parse_args('+f X ++bar Y'.split())\n"
"Namespace(bar='Y', f='X')"

msgid "The ``prefix_chars=`` argument defaults to ``'-'``. Supplying a set of characters that does not include ``-`` will cause ``-f/--foo`` options to be disallowed."
msgstr "مقدار پیش‌فرض آرگومان ``prefix_chars=`` برابر ``'-'`` است. ارائه مجموعه‌ای از نویسه‌ها که شامل ``-`` نباشد، باعث غیرمجاز شدن گزینه‌های ``-f/--foo`` می‌شود."

msgid "fromfile_prefix_chars"
msgstr "fromfile_prefix_chars"

msgid "Sometimes, when dealing with a particularly long argument list, it may make sense to keep the list of arguments in a file rather than typing it out at the command line.  If the ``fromfile_prefix_chars=`` argument is given to the :class:`ArgumentParser` constructor, then arguments that start with any of the specified characters will be treated as files, and will be replaced by the arguments they contain.  For example::"
msgstr "گاهی، هنگام کار با یک فهرست آرگومان بسیار طولانی، ممکن است منطقی باشد که فهرست آرگومان‌ها را در یک پرونده نگه دارید، به‌جای آن‌که آن را در خط فرمان تایپ کنید. اگر آرگومان ``fromfile_prefix_chars=`` به سازنده‌ی :class:`ArgumentParser` داده شود، آرگومان‌هایی که با هر یک از نویسه‌های مشخص‌شده آغاز می‌شوند، به‌عنوان پرونده در نظر گرفته می‌شوند و با آرگومان‌هایی که در بر دارند جایگزین می‌شوند. برای مثال::"

msgid ""
">>> with open('args.txt', 'w', encoding=sys.getfilesystemencoding()) as fp:\n"
"...     fp.write('-f\\nbar')\n"
"...\n"
">>> parser = argparse.ArgumentParser(fromfile_prefix_chars='@')\n"
">>> parser.add_argument('-f')\n"
">>> parser.parse_args(['-f', 'foo', '@args.txt'])\n"
"Namespace(f='bar')"
msgstr ""
">>> with open('args.txt', 'w', encoding=sys.getfilesystemencoding()) as fp:\n"
"...     fp.write('-f\\nbar')\n"
"...\n"
">>> parser = argparse.ArgumentParser(fromfile_prefix_chars='@')\n"
">>> parser.add_argument('-f')\n"
">>> parser.parse_args(['-f', 'foo', '@args.txt'])\n"
"Namespace(f='bar')"

msgid "Arguments read from a file must be one per line by default (but see also :meth:`~ArgumentParser.convert_arg_line_to_args`) and are treated as if they were in the same place as the original file referencing argument on the command line.  So in the example above, the expression ``['-f', 'foo', '@args.txt']`` is considered equivalent to the expression ``['-f', 'foo', '-f', 'bar']``."
msgstr "آرگومان‌های خوانده‌شده از یک پرونده باید به‌طور پیش‌فرض یکی در هر خط باشند (اما :meth:`~ArgumentParser.convert_arg_line_to_args` را نیز ببینید) و طوری با آن‌ها رفتار می‌شود که گویی در همان جایگاه آرگومان اصلی ارجاع‌دهنده به پرونده در خط فرمان قرار دارند. بنابراین در مثال بالا، عبارت ``['-f', 'foo', '@args.txt']`` معادل عبارت ``['-f', 'foo', '-f', 'bar']`` در نظر گرفته می‌شود."

msgid "Each line is treated as a single argument, so an empty line is read as an empty string (``''``)."
msgstr "هر خط به‌عنوان یک آرگومان واحد در نظر گرفته می‌شود، بنابراین یک خط خالی به‌عنوان یک رشته خالی (``''``) خوانده می‌شود."

msgid ":class:`ArgumentParser` uses :term:`filesystem encoding and error handler` to read the file containing arguments."
msgstr ":class:`ArgumentParser` از :term:`filesystem encoding and error handler` برای خواندن پرونده حاوی آرگومان‌ها استفاده می‌کند."

msgid "The ``fromfile_prefix_chars=`` argument defaults to ``None``, meaning that arguments will never be treated as file references."
msgstr "مقدار پیش‌فرض آرگومان ``fromfile_prefix_chars=`` برابر ``None`` است، به این معنا که آرگومان‌ها هرگز به‌عنوان ارجاع به پرونده در نظر گرفته نمی‌شوند."

msgid ":class:`ArgumentParser` changed encoding and errors to read arguments files from default (e.g. :func:`locale.getpreferredencoding(False) <locale.getpreferredencoding>` and ``\"strict\"``) to the :term:`filesystem encoding and error handler`. Arguments file should be encoded in UTF-8 instead of ANSI Codepage on Windows."
msgstr ":class:`ArgumentParser` کدگذاری و خطاها را برای خواندن پرونده‌های آرگومان از پیش‌فرض (برای مثال :func:`locale.getpreferredencoding(False) <locale.getpreferredencoding>` و ``\"strict\"``) به :term:`کدگذاری و هندلر خطای سامانه فایل‌بندی <filesystem encoding and error handler>` تغییر داد. پرونده آرگومان‌ها باید در ویندوز به‌جای ANSI Codepage با UTF-8 کدگذاری شود."

msgid "argument_default"
msgstr "argument_default"

msgid "Generally, argument defaults are specified either by passing a default to :meth:`~ArgumentParser.add_argument` or by calling the :meth:`~ArgumentParser.set_defaults` methods with a specific set of name-value pairs.  Sometimes however, it may be useful to specify a single parser-wide default for arguments.  This can be accomplished by passing the ``argument_default=`` keyword argument to :class:`ArgumentParser`.  For example, to globally suppress attribute creation on :meth:`~ArgumentParser.parse_args` calls, we supply ``argument_default=SUPPRESS``::"
msgstr "به‌طور معمول، مقادیر پیش‌فرض آرگومان‌ها یا با ارسال یک مقدار پیش‌فرض به :meth:`~ArgumentParser.add_argument` یا با فراخوانی متد :meth:`~ArgumentParser.set_defaults` با مجموعه‌ای مشخص از جفت‌های نام-مقدار مشخص می‌شوند. با این حال، گاهی ممکن است مشخص کردن یک پیش‌فرض واحد در سطح پارسر برای آرگومان‌ها مفید باشد. این کار را می‌توان با ارسال آرگومان کلیدواژه‌ای ``argument_default=`` به :class:`ArgumentParser` انجام داد. برای مثال، برای جلوگیری به‌صورت سراسری از ایجاد ویژگی در فراخوانی‌های :meth:`~ArgumentParser.parse_args`، ``argument_default=SUPPRESS`` را قرار می‌دهیم::"

msgid ""
">>> parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)\n"
">>> parser.add_argument('--foo')\n"
">>> parser.add_argument('bar', nargs='?')\n"
">>> parser.parse_args(['--foo', '1', 'BAR'])\n"
"Namespace(bar='BAR', foo='1')\n"
">>> parser.parse_args([])\n"
"Namespace()"
msgstr ""
">>> parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)\n"
">>> parser.add_argument('--foo')\n"
">>> parser.add_argument('bar', nargs='?')\n"
">>> parser.parse_args(['--foo', '1', 'BAR'])\n"
"Namespace(bar='BAR', foo='1')\n"
">>> parser.parse_args([])\n"
"Namespace()"

msgid "allow_abbrev"
msgstr "allow_abbrev"

msgid "Normally, when you pass an argument list to the :meth:`~ArgumentParser.parse_args` method of an :class:`ArgumentParser`, it :ref:`recognizes abbreviations <prefix-matching>` of long options."
msgstr "به‌طور معمول، هنگامی که یک فهرست آرگومان را به متد :meth:`~ArgumentParser.parse_args` از یک :class:`ArgumentParser` ارسال می‌کنید، این متد برای گزینه‌های بلند :ref:`مخفف‌ها را می‌شناسد <prefix-matching>`."

msgid "This feature can be disabled by setting ``allow_abbrev`` to ``False``::"
msgstr "این قابلیت را می‌توان با تنظیم ``allow_abbrev`` روی ``False`` غیرفعال کرد::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', allow_abbrev=False)\n"
">>> parser.add_argument('--foobar', action='store_true')\n"
">>> parser.add_argument('--foonley', action='store_false')\n"
">>> parser.parse_args(['--foon'])\n"
"usage: PROG [-h] [--foobar] [--foonley]\n"
"PROG: error: unrecognized arguments: --foon"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG', allow_abbrev=False)\n"
">>> parser.add_argument('--foobar', action='store_true')\n"
">>> parser.add_argument('--foonley', action='store_false')\n"
">>> parser.parse_args(['--foon'])\n"
"usage: PROG [-h] [--foobar] [--foonley]\n"
"PROG: error: unrecognized arguments: --foon"

msgid "conflict_handler"
msgstr "conflict_handler"

msgid ":class:`ArgumentParser` objects do not allow two actions with the same option string.  By default, :class:`ArgumentParser` objects raise an exception if an attempt is made to create an argument with an option string that is already in use::"
msgstr "اشیاء :class:`ArgumentParser` اجازه نمی‌دهند دو اکشن با رشته‌ی گزینه یکسان وجود داشته باشند. به‌طور پیش‌فرض، اشیاء :class:`ArgumentParser` در صورتی که تلاشی برای ایجاد آرگومانی با رشته‌ی گزینه‌ای که از قبل در حال استفاده است انجام شود، استثنایی پرتاب می‌کنند::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-f', '--foo', help='old foo help')\n"
">>> parser.add_argument('--foo', help='new foo help')\n"
"Traceback (most recent call last):\n"
" ..\n"
"ArgumentError: argument --foo: conflicting option string(s): --foo"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-f', '--foo', help='old foo help')\n"
">>> parser.add_argument('--foo', help='new foo help')\n"
"Traceback (most recent call last):\n"
" ..\n"
"ArgumentError: argument --foo: conflicting option string(s): --foo"

msgid "Sometimes (e.g. when using parents_) it may be useful to simply override any older arguments with the same option string.  To get this behavior, the value ``'resolve'`` can be supplied to the ``conflict_handler=`` argument of :class:`ArgumentParser`::"
msgstr "گاهی (مثلاً هنگام استفاده از parents_) ممکن است مفید باشد که هر آرگومان قدیمی‌تری با همان رشته‌ی گزینه به‌سادگی بازنویسی شود. برای دستیابی به این رفتار، می‌توان مقدار ``'resolve'`` را به آرگومان ``conflict_handler=`` در :class:`ArgumentParser` داد::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', conflict_handler='resolve')\n"
">>> parser.add_argument('-f', '--foo', help='old foo help')\n"
">>> parser.add_argument('--foo', help='new foo help')\n"
">>> parser.print_help()\n"
"usage: PROG [-h] [-f FOO] [--foo FOO]\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" -f FOO      old foo help\n"
" --foo FOO   new foo help"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG', conflict_handler='resolve')\n"
">>> parser.add_argument('-f', '--foo', help='old foo help')\n"
">>> parser.add_argument('--foo', help='new foo help')\n"
">>> parser.print_help()\n"
"usage: PROG [-h] [-f FOO] [--foo FOO]\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" -f FOO      old foo help\n"
" --foo FOO   new foo help"

msgid "Note that :class:`ArgumentParser` objects only remove an action if all of its option strings are overridden.  So, in the example above, the old ``-f/--foo`` action is retained as the ``-f`` action, because only the ``--foo`` option string was overridden."
msgstr "توجه داشته باشید که اشیاء :class:`ArgumentParser` یک اکشنرا فقط در صورتی حذف می‌کنند که همه رشته‌های گزینه (option strings) آن بازنویسی‌شده باشند. بنابراین، در مثال بالا، اکشن قدیمی ``-f/--foo`` به‌عنوان اکشن ``-f`` حفظ می‌شود، زیرا فقط رشته گزینه ``--foo`` بازنویسی‌شده است."

msgid "add_help"
msgstr "add_help"

msgid "By default, :class:`ArgumentParser` objects add an option which simply displays the parser's help message. If ``-h`` or ``--help`` is supplied at the command line, the :class:`!ArgumentParser` help will be printed."
msgstr "به‌طور پیش‌فرض، اشیای :class:`ArgumentParser` گزینه‌ای اضافه می‌کنند که صرفاً پیام راهنمای پارسر را نمایش می‌دهد. اگر ``-h`` یا ``--help`` در خط فرمان ارائه شود، راهنمای :class:`!ArgumentParser` چاپ خواهد شد."

msgid "Occasionally, it may be useful to disable the addition of this help option. This can be achieved by passing ``False`` as the ``add_help=`` argument to :class:`ArgumentParser`::"
msgstr "گاهی اوقات، ممکن است غیرفعال کردن افزودن این گزینه راهنما مفید باشد. این کار را می‌توان با ارسال ``False`` به‌عنوان آرگومان ``add_help=`` به :class:`ArgumentParser` انجام داد::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)\n"
">>> parser.add_argument('--foo', help='foo help')\n"
">>> parser.print_help()\n"
"usage: PROG [--foo FOO]\n"
"\n"
"options:\n"
" --foo FOO  foo help"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)\n"
">>> parser.add_argument('--foo', help='foo help')\n"
">>> parser.print_help()\n"
"usage: PROG [--foo FOO]\n"
"\n"
"options:\n"
" --foo FOO  foo help"

msgid "The help option is typically ``-h/--help``. The exception to this is if the ``prefix_chars=`` is specified and does not include ``-``, in which case ``-h`` and ``--help`` are not valid options.  In this case, the first character in ``prefix_chars`` is used to prefix the help options::"
msgstr "گزینه راهنما معمولاً ``-h/--help`` است. استثنای این حالت زمانی است که ``prefix_chars=`` مشخص شده باشد و شامل ``-`` نباشد، که در این صورت ``-h`` و ``--help`` گزینه‌های معتبری نیستند. در این حالت، از اولین نویسه‌ی ``prefix_chars`` برای پیشوندگذاری گزینه‌های راهنما استفاده می‌شود::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='+/')\n"
">>> parser.print_help()\n"
"usage: PROG [+h]\n"
"\n"
"options:\n"
"  +h, ++help  show this help message and exit"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='+/')\n"
">>> parser.print_help()\n"
"usage: PROG [+h]\n"
"\n"
"options:\n"
"  +h, ++help  show this help message and exit"

msgid "exit_on_error"
msgstr "exit_on_error"

msgid "Normally, when you pass an invalid argument list to the :meth:`~ArgumentParser.parse_args` method of an :class:`ArgumentParser`, it will print a *message* to :data:`sys.stderr` and exit with a status code of 2."
msgstr "به‌طور معمول، هنگامی که یک فهرست آرگومان‌های نامعتبر را به متد :meth:`~ArgumentParser.parse_args` از یک :class:`ArgumentParser` ارسال می‌کنید، *پیامی* را در :data:`sys.stderr` چاپ می‌کند و با کد وضعیت ۲ خارج می‌شود."

msgid "If the user would like to catch errors manually, the feature can be enabled by setting ``exit_on_error`` to ``False``::"
msgstr "اگر کاربر بخواهد خطاها را به‌صورت دستی بگیرد، می‌توان این قابلیت را با تنظیم ``exit_on_error`` روی ``False`` فعال کرد::"

msgid ""
">>> parser = argparse.ArgumentParser(exit_on_error=False)\n"
">>> parser.add_argument('--integers', type=int)\n"
"_StoreAction(option_strings=['--integers'], dest='integers', nargs=None, const=None, default=None, type=<class 'int'>, choices=None, help=None, metavar=None)\n"
">>> try:\n"
"...     parser.parse_args('--integers a'.split())\n"
"... except argparse.ArgumentError:\n"
"...     print('Catching an argumentError')\n"
"...\n"
"Catching an argumentError"
msgstr ""
">>> parser = argparse.ArgumentParser(exit_on_error=False)\n"
">>> parser.add_argument('--integers', type=int)\n"
"_StoreAction(option_strings=['--integers'], dest='integers', nargs=None, const=None, default=None, type=<class 'int'>, choices=None, help=None, metavar=None)\n"
">>> try:\n"
"...     parser.parse_args('--integers a'.split())\n"
"... except argparse.ArgumentError:\n"
"...     print('Catching an argumentError')\n"
"...\n"
"Catching an argumentError"

msgid "suggest_on_error"
msgstr "suggest_on_error"

msgid "By default, when a user passes an invalid argument choice or subparser name, :class:`ArgumentParser` will exit with error info and provide suggestions for mistyped arguments. The error message will list the permissible argument choices (if specified) or subparser names, along with a \"maybe you meant\" suggestion if a close match is found. Note that this only applies for arguments when the choices specified are strings::"
msgstr "به طور پیش‌فرض، هنگامی که کاربری یک انتخاب آرگومان یا نام زیرپارسر نامعتبر را ارسال کند، کلاس :class:`ArgumentParser` با اطلاعات خطا خارج می‌شود و پیشنهادهایی را برای آرگومان‌های اشتباه تایپ‌شده ارائه می‌دهد. پیام خطا انتخاب‌های مجاز آرگومان (در صورت مشخص شدن) یا نام‌های زیرپارسر را فهرست می‌کند، همراه با یک پیشنهاد «شاید منظور شما این بوده است» اگر تطبیق نزدیکی پیدا شود. توجه داشته باشید که این مورد تنها برای آرگومان‌هایی اعمال می‌شود که انتخاب‌های مشخص‌شده رشته باشند::"

msgid ""
">>> parser = argparse.ArgumentParser(suggest_on_error=True)\n"
">>> parser.add_argument('--action', choices=['debug', 'dryrun'])\n"
">>> parser.parse_args(['--action', 'debugg'])\n"
"usage: tester.py [-h] [--action {debug,dryrun}]\n"
"tester.py: error: argument --action: invalid choice: 'debugg', maybe you meant 'debug'? (choose from debug, dryrun)"
msgstr ""
">>> parser = argparse.ArgumentParser(suggest_on_error=True)\n"
">>> parser.add_argument('--action', choices=['debug', 'dryrun'])\n"
">>> parser.parse_args(['--action', 'debugg'])\n"
"usage: tester.py [-h] [--action {debug,dryrun}]\n"
"tester.py: error: argument --action: invalid choice: 'debugg', maybe you meant 'debug'? (choose from debug, dryrun)"

msgid "You can disable suggestions by setting ``suggest_on_error`` to ``False``."
msgstr "می‌توانید با تنظیم ``suggest_on_error`` روی ``False`` پیشنهادها را غیرفعال کنید."

msgid "Changed default value of ``suggest_on_error`` from ``False`` to ``True``."
msgstr "مقدار پیش‌فرض ``suggest_on_error`` از ``False`` به ``True`` تغییر یافت."

msgid "color"
msgstr "رنگ"

msgid "By default, the help message is printed in color using `ANSI escape sequences <https://en.wikipedia.org/wiki/ANSI_escape_code>`__. If you want plain text help messages, you can disable this :ref:`in your local environment <using-on-controlling-color>`, or in the argument parser itself by setting ``color`` to ``False``::"
msgstr "به‌طور پیش‌فرض، پیام راهنما با استفاده از `ANSI escape sequences <https://fa.wikipedia.org/wiki/کدهای_فرار_انسی>`__ به‌صورت رنگی چاپ می‌شود. اگر پیام‌های راهنما را به‌صورت متن ساده می‌خواهید، می‌توانید آن را :ref:`در محیط محلی خود <using-on-controlling-color>` یا در خود پارسر آرگومان با تنظیم ``color`` روی ``False`` غیرفعال کنید::"

msgid ""
">>> parser = argparse.ArgumentParser(description='Process some integers.',\n"
"...                                  color=False)\n"
">>> parser.add_argument('--action', choices=['sum', 'max'])\n"
">>> parser.add_argument('integers', metavar='N', type=int, nargs='+',\n"
"...                     help='an integer for the accumulator')\n"
">>> parser.parse_args(['--help'])"
msgstr ""
">>> parser = argparse.ArgumentParser(description='Process some integers.',\n"
"...                                  color=False)\n"
">>> parser.add_argument('--action', choices=['sum', 'max'])\n"
">>> parser.add_argument('integers', metavar='N', type=int, nargs='+',\n"
"...                     help='an integer for the accumulator')\n"
">>> parser.parse_args(['--help'])"

msgid "Note that when ``color=True``, colored output depends on both environment variables and terminal capabilities.  However, if ``color=False``, colored output is always disabled, even if environment variables like ``FORCE_COLOR`` are set."
msgstr "توجه داشته باشید که هنگامی که ``color=True`` باشد، خروجی رنگی هم به متغیرهای محیطی و هم به قابلیت‌های پایانه بستگی دارد. با این حال، اگر ``color=False`` باشد، خروجی رنگی همیشه غیرفعال است، حتی اگر متغیرهای محیطی مانند ``FORCE_COLOR`` تنظیم شده باشند."

msgid "To highlight inline code in your description, epilog, or argument ``help`` text, you can use single or double backticks::"
msgstr "برای برجسته‌سازی کد درون‌خطی در توضیحات، epilog، یا متن ``help`` آرگومان، می‌توانید از علامت‌های نقل‌قول معکوس تکی یا دوتایی استفاده کنید::"

msgid ""
">>> parser = argparse.ArgumentParser(\n"
"...     formatter_class=argparse.RawDescriptionHelpFormatter,\n"
"...     description='Run ``python -m myapp`` to start.',\n"
"...     epilog='''Examples:\n"
"...   `python -m myapp --verbose`\n"
"...   ``python -m myapp --config settings.json``\n"
"... ''')\n"
">>> parser.add_argument('--foo', help='set the `foo` value')"
msgstr ""
">>> parser = argparse.ArgumentParser(\n"
"...     formatter_class=argparse.RawDescriptionHelpFormatter,\n"
"...     description='Run ``python -m myapp`` to start.',\n"
"...     epilog='''Examples:\n"
"...   `python -m myapp --verbose`\n"
"...   ``python -m myapp --config settings.json``\n"
"... ''')\n"
">>> parser.add_argument('--foo', help='set the `foo` value')"

msgid "When colors are enabled, the text inside backticks will be displayed in a distinct color to help examples stand out. When colors are disabled, backticks are preserved as-is, which is readable in plain text."
msgstr "هنگامی که رنگ‌ها فعال هستند، متن داخل نقل‌قول‌های معکوس با رنگ متمایزی نمایش داده می‌شود تا به برجسته شدن مثال‌ها کمک کند. هنگامی که رنگ‌ها غیرفعال هستند، نقل‌قول‌های معکوس دقیقاً به همان شکل حفظ می‌شوند که در متن ساده خوانا است."

msgid "The add_argument() method"
msgstr "متد add_argument()"

msgid "Define how a single command-line argument should be parsed.  Each parameter has its own more detailed description below, but in short they are:"
msgstr "تعریف می‌کند که یک آرگومان خط فرمان باید چگونه تجزیه شود. هر پارامتر در زیر توضیح مفصل‌تری دارد، اما به‌طور خلاصه عبارت‌اند از:"

msgid "`name or flags`_ - Either a name or a list of option strings, e.g. ``'foo'`` or ``'-f', '--foo'``."
msgstr "`name or flags`_ - یا یک نام یا فهرستی از رشته‌های گزینه، برای مثال ``'foo'`` یا ``'-f', '--foo'``."

msgid "action_ - The basic type of action to be taken when this argument is encountered at the command line."
msgstr "action_ - نوع پایه‌ی اکشنی که هنگام مواجهه با این آرگومان در خط فرمان انجام می‌شود."

msgid "nargs_ - The number of command-line arguments that should be consumed."
msgstr "nargs_ - تعداد آرگومان‌های خط فرمان که باید مصرف شوند."

msgid "const_ - A constant value required by some action_ and nargs_ selections."
msgstr "const_ - مقدار ثابتی که برخی انتخاب‌های action_ و nargs_ به آن نیاز دارند."

msgid "default_ - The value produced if the argument is absent from the command line and if it is absent from the namespace object."
msgstr "default_ - مقداری که اگر آرگومان در خط فرمان وجود نداشته باشد و در شیء فضای نام نیز غایب باشد، تولید می‌شود."

msgid "type_ - The type to which the command-line argument should be converted."
msgstr "type_ - نوعی که آرگومان خط فرمان باید به آن تبدیل شود."

msgid "choices_ - A sequence of the allowable values for the argument."
msgstr "choices_ - دنباله‌ای از مقادیر مجاز برای آرگومان."

msgid "required_ - Whether or not the command-line option may be omitted (optionals only)."
msgstr "required_ - اینکه آیا می‌توان گزینه خط فرمان را حذف کرد یا خیر (فقط گزینه‌های اختیاری)."

msgid "help_ - A brief description of what the argument does."
msgstr "help_ - شرحی مختصر از کاری که آرگومان انجام می‌دهد."

msgid "metavar_ - A name for the argument in usage messages."
msgstr "metavar_ - نامی برای آرگومان در پیام‌های کاربرد."

msgid "dest_ - The name of the attribute to be added to the object returned by :meth:`parse_args`."
msgstr "dest_ - نام ویژگی‌ای که به شیء برگردانده‌شده توسط :meth:`parse_args` افزوده می‌شود."

msgid "deprecated_ - Whether or not use of the argument is deprecated."
msgstr "deprecated_ - اینکه استفاده از آرگومان منسوخ است یا خیر."

msgid "The method returns an :class:`Action` object representing the argument."
msgstr "این متد یک شیء :class:`Action` برمی‌گرداند که نمایانگر آرگومان است."

msgid "name or flags"
msgstr "نام یا پرچم‌ها"

msgid "The :meth:`~ArgumentParser.add_argument` method must know whether an optional argument, like ``-f`` or ``--foo``, or a positional argument, like a list of filenames, is expected.  The first arguments passed to :meth:`~ArgumentParser.add_argument` must therefore be either a series of flags, or a simple argument name."
msgstr "متد :meth:`~ArgumentParser.add_argument` باید بداند که آیا یک آرگومان اختیاری، مانند ``-f`` یا ``--foo``، یا یک آرگومان جایگاهی، مانند فهرستی از نام پرونده‌ها، انتظار می‌رود. بنابراین اولین آرگومان‌های ارسال‌شده به :meth:`~ArgumentParser.add_argument` باید یا مجموعه‌ای از پرچم‌ها باشند یا یک نام آرگومان ساده."

msgid "For example, an optional argument could be created like::"
msgstr "برای مثال، می‌توان یک آرگومان اختیاری به این صورت ایجاد کرد::"

msgid ">>> parser.add_argument('-f', '--foo')"
msgstr ">>> parser.add_argument('-f', '--foo')"

msgid "while a positional argument could be created like::"
msgstr "در حالی که یک آرگومان جایگاهی را می‌توان به این شکل ایجاد کرد::"

msgid ">>> parser.add_argument('bar')"
msgstr ">>> parser.add_argument('bar')"

msgid "When :meth:`~ArgumentParser.parse_args` is called, optional arguments will be identified by the ``-`` prefix, and the remaining arguments will be assumed to be positional::"
msgstr "هنگامی که :meth:`~ArgumentParser.parse_args` فراخوانی می‌شود، آرگومان‌های اختیاری با پیشوند ``-`` شناسایی می‌شوند، و آرگومان‌های باقی‌مانده جایگاهی فرض می‌شوند::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-f', '--foo')\n"
">>> parser.add_argument('bar')\n"
">>> parser.parse_args(['BAR'])\n"
"Namespace(bar='BAR', foo=None)\n"
">>> parser.parse_args(['BAR', '--foo', 'FOO'])\n"
"Namespace(bar='BAR', foo='FOO')\n"
">>> parser.parse_args(['--foo', 'FOO'])\n"
"usage: PROG [-h] [-f FOO] bar\n"
"PROG: error: the following arguments are required: bar"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-f', '--foo')\n"
">>> parser.add_argument('bar')\n"
">>> parser.parse_args(['BAR'])\n"
"Namespace(bar='BAR', foo=None)\n"
">>> parser.parse_args(['BAR', '--foo', 'FOO'])\n"
"Namespace(bar='BAR', foo='FOO')\n"
">>> parser.parse_args(['--foo', 'FOO'])\n"
"usage: PROG [-h] [-f FOO] bar\n"
"PROG: error: the following arguments are required: bar"

msgid "By default, :mod:`!argparse` automatically handles the internal naming and display names of arguments, simplifying the process without requiring additional configuration. As such, you do not need to specify the dest_ and metavar_ parameters. For optional arguments, the dest_ parameter defaults to the argument name, with underscores ``_`` replacing hyphens ``-``. The metavar_ parameter defaults to the upper-cased name. For example::"
msgstr "به‌طور پیش‌فرض، :mod:`!argparse` نام‌گذاری داخلی و نام‌های نمایشی آرگومان‌ها را به‌طور خودکار مدیریت می‌کند و فرآیند را بدون نیاز به پیکربندی اضافی ساده می‌سازد. بنابراین، نیازی به مشخص کردن پارامترهای dest_ و metavar_ ندارید. برای آرگومان‌های اختیاری، پارامتر dest_ به‌طور پیش‌فرض برابر با نام آرگومان است، با جایگزینی زیرخط ``_`` به‌جای خط‌تیره ``-``. پارامتر metavar_ به‌طور پیش‌فرض برابر با نام با حروف بزرگ است. برای مثال::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('--foo-bar')\n"
">>> parser.parse_args(['--foo-bar', 'FOO-BAR'])\n"
"Namespace(foo_bar='FOO-BAR')\n"
">>> parser.print_help()\n"
"usage:  [-h] [--foo-bar FOO-BAR]\n"
"\n"
"optional arguments:\n"
" -h, --help  show this help message and exit\n"
" --foo-bar FOO-BAR"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('--foo-bar')\n"
">>> parser.parse_args(['--foo-bar', 'FOO-BAR'])\n"
"Namespace(foo_bar='FOO-BAR')\n"
">>> parser.print_help()\n"
"usage:  [-h] [--foo-bar FOO-BAR]\n"
"\n"
"optional arguments:\n"
" -h, --help  show this help message and exit\n"
" --foo-bar FOO-BAR"

msgid "action"
msgstr "action"

msgid ":class:`ArgumentParser` objects associate command-line arguments with actions.  These actions can do just about anything with the command-line arguments associated with them, though most actions simply add an attribute to the object returned by :meth:`~ArgumentParser.parse_args`.  The ``action`` keyword argument specifies how the command-line arguments should be handled. The supplied actions are:"
msgstr "اشیای :class:`ArgumentParser` آرگومان‌های خط فرمان را به اکشن‌ها مرتبط می‌کنند. این اکشن‌ها می‌توانند تقریباً هر کاری را با آرگومان‌های خط فرمان مرتبط با خود انجام دهند، اگرچه بیشتر اکشن‌ها صرفاً یک ویژگی به شیء برگردانده‌شده از :meth:`~ArgumentParser.parse_args` اضافه می‌کنند. آرگومان کلیدواژه‌ای ``action`` مشخص می‌کند که آرگومان‌های خط فرمان باید چگونه مدیریت شوند. اکشن‌های فراهم‌شده عبارت‌اند از:"

msgid "``'store'`` - This just stores the argument's value.  This is the default action."
msgstr "``'store'`` - این فقط مقدار آرگومان را ذخیره می‌کند. این اکشن پیش‌فرض است."

msgid "``'store_const'`` - This stores the value specified by the const_ keyword argument; note that the const_ keyword argument defaults to ``None``.  The ``'store_const'`` action is most commonly used with optional arguments that specify some sort of flag.  For example::"
msgstr "``'store_const'`` - این مقدار مشخص‌شده با آرگومان کلیدواژه‌ای const_ را ذخیره می‌کند؛ توجه داشته باشید که مقدار پیش‌فرض آرگومان کلیدواژه‌ای const_ برابر ``None`` است. اکشن ``'store_const'`` بیشتر با آرگومان‌های اختیاری استفاده می‌شود که نوعی پرچم را مشخص می‌کنند. برای مثال::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action='store_const', const=42)\n"
">>> parser.parse_args(['--foo'])\n"
"Namespace(foo=42)"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action='store_const', const=42)\n"
">>> parser.parse_args(['--foo'])\n"
"Namespace(foo=42)"

msgid "``'store_true'`` and ``'store_false'`` - These are special cases of ``'store_const'`` that respectively store the values ``True`` and ``False`` with default values of ``False`` and ``True``::"
msgstr "``'store_true'`` و ``'store_false'`` - این‌ها موارد خاصی از ``'store_const'`` هستند که به‌ترتیب مقادیر ``True`` و ``False`` را با مقادیر پیش‌فرض ``False`` و ``True`` ذخیره می‌کنند::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action='store_true')\n"
">>> parser.add_argument('--bar', action='store_false')\n"
">>> parser.add_argument('--baz', action='store_false')\n"
">>> parser.parse_args('--foo --bar'.split())\n"
"Namespace(foo=True, bar=False, baz=True)"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action='store_true')\n"
">>> parser.add_argument('--bar', action='store_false')\n"
">>> parser.add_argument('--baz', action='store_false')\n"
">>> parser.parse_args('--foo --bar'.split())\n"
"Namespace(foo=True, bar=False, baz=True)"

msgid "These defaults apply when the options are absent. They can be overridden by default_ or argument_default_."
msgstr "این مقادیر پیش‌فرض زمانی اعمال می‌شوند که گزینه‌ها وجود نداشته باشند. آن‌ها را می‌توان توسط default_ یا argument_default_ بازنویسی کرد."

msgid "``'append'`` - This appends each argument value to a list. It is useful for allowing an option to be specified multiple times. If the default value is a non-empty list, the parsed value will start with the default list's elements and any values from the command line will be appended after those default values. Example usage::"
msgstr "``'append'`` - این عمل هر مقدار آرگومان را به یک فهرست اضافه می‌کند. این برای اجازه دادن به اینکه یک گزینه چندین بار مشخص شود، مفید است. اگر مقدار پیش‌فرض یک فهرست غیرخالی باشد، مقدار تجزیه‌شده با عناصر فهرست پیش‌فرض آغاز می‌شود و هر مقداری از خط فرمان پس از آن مقادیر پیش‌فرض اضافه می‌شود. نمونه استفاده::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action='append', default=['0'])\n"
">>> parser.parse_args('--foo 1 --foo 2'.split())\n"
"Namespace(foo=['0', '1', '2'])"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action='append', default=['0'])\n"
">>> parser.parse_args('--foo 1 --foo 2'.split())\n"
"Namespace(foo=['0', '1', '2'])"

msgid "``'append_const'`` - This appends the value specified by the const_ keyword argument to a list; note that the const_ keyword argument defaults to ``None``. The ``'append_const'`` action is typically useful when multiple arguments need to store constants to the same list. For example::"
msgstr "``'append_const'`` - این کنش مقدار مشخص‌شده توسط آرگومان کلیدواژه‌ای const_ را به یک فهرست الحاق می‌کند؛ توجه داشته باشید که مقدار پیش‌فرض آرگومان کلیدواژه‌ای const_ برابر ``None`` است. کنش ``'append_const'`` معمولاً زمانی مفید است که چند آرگومان نیاز دارند ثابت‌ها را در یک فهرست مشترک ذخیره کنند. برای مثال::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--str', dest='types', action='append_const', const=str)\n"
">>> parser.add_argument('--int', dest='types', action='append_const', const=int)\n"
">>> parser.parse_args('--str --int'.split())\n"
"Namespace(types=[<class 'str'>, <class 'int'>])"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--str', dest='types', action='append_const', const=str)\n"
">>> parser.add_argument('--int', dest='types', action='append_const', const=int)\n"
">>> parser.parse_args('--str --int'.split())\n"
"Namespace(types=[<class 'str'>, <class 'int'>])"

msgid "``'extend'`` - This appends each item from a multi-value argument to a list. The ``'extend'`` action is typically used with the nargs_ keyword argument value ``'+'`` or ``'*'``. Note that when nargs_ is ``None`` (the default) or ``'?'``, each character of the argument string will be appended to the list. Example usage::"
msgstr "``'extend'`` - این هر یک از آیتم‌های یک آرگومان چندمقداری را به یک فهرست اضافه می‌کند. اکشن  ``'extend'`` معمولاً همراه با مقدار ``'+'`` یا ``'*'`` برای آرگومان کلیدواژه‌ای nargs_ استفاده می‌شود. توجه داشته باشید که وقتی nargs_ برابر با ``None`` (پیش‌فرض) یا ``'?'`` باشد، هر نویسه‌ی رشته‌ی آرگومان به فهرست اضافه خواهد شد. نمونه کاربرد::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument(\"--foo\", action=\"extend\", nargs=\"+\", type=str)\n"
">>> parser.parse_args([\"--foo\", \"f1\", \"--foo\", \"f2\", \"f3\", \"f4\"])\n"
"Namespace(foo=['f1', 'f2', 'f3', 'f4'])"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument(\"--foo\", action=\"extend\", nargs=\"+\", type=str)\n"
">>> parser.parse_args([\"--foo\", \"f1\", \"--foo\", \"f2\", \"f3\", \"f4\"])\n"
"Namespace(foo=['f1', 'f2', 'f3', 'f4'])"

msgid "``'count'`` - This counts the number of times an argument occurs. For example, this is useful for increasing verbosity levels::"
msgstr "``'count'`` - این تعداد دفعاتی را که یک آرگومان رخ می‌دهد می‌شمارد. برای مثال، این برای افزایش سطوح پرگویی مفید است::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--verbose', '-v', action='count', default=0)\n"
">>> parser.parse_args(['-vvv'])\n"
"Namespace(verbose=3)"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--verbose', '-v', action='count', default=0)\n"
">>> parser.parse_args(['-vvv'])\n"
"Namespace(verbose=3)"

msgid "Unless explicitly set, the *default* will be ``None``. If the default value is a non-zero number, the count starts from that number rather than from zero."
msgstr "مگر اینکه به صراحت تنظیم شده باشد، *default* برابر با ``None`` خواهد بود. اگر مقدار پیش‌فرض عددی غیرصفر باشد، شمارش از آن عدد آغاز می‌شود نه از صفر."

msgid "``'help'`` - This prints a complete help message for all the options in the current parser and then exits. By default a help action is automatically added to the parser. See :class:`ArgumentParser` for details of how the output is created."
msgstr "``'help'`` - این یک پیام راهنمای کامل برای همه گزینه‌های پارسر فعلی را چاپ می‌کند و سپس خارج می‌شود. به‌طور پیش‌فرض، یک اکشن راهنما به‌صورت خودکار به پارسر اضافه می‌شود. برای جزئیات چگونگی ایجاد خروجی، :class:`ArgumentParser` را ببینید."

msgid "``'version'`` - This expects a ``version=`` keyword argument in the :meth:`~ArgumentParser.add_argument` call, and prints version information and exits when invoked::"
msgstr "``'version'`` - این گزینه به یک آرگومان کلیدواژه‌ای ``version=`` در فراخوانی :meth:`~ArgumentParser.add_argument` نیاز دارد و هنگام فراخوانی، اطلاعات نسخه را چاپ کرده و خارج می‌شود::"

msgid ""
">>> import argparse\n"
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('--version', action='version', version='%(prog)s 2.0')\n"
">>> parser.parse_args(['--version'])\n"
"PROG 2.0"
msgstr ""
">>> import argparse\n"
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('--version', action='version', version='%(prog)s 2.0')\n"
">>> parser.parse_args(['--version'])\n"
"PROG 2.0"

msgid "You may also specify an arbitrary action by passing an :class:`Action` subclass (e.g. :class:`BooleanOptionalAction`) or other object that implements the same interface. Only actions that consume command-line arguments (e.g. ``'store'``, ``'append'``, ``'extend'``, or custom actions with non-zero ``nargs``) can be used with positional arguments."
msgstr "همچنین می‌توانید با ارسال یک زیرکلاس از :class:`Action` (برای مثال :class:`BooleanOptionalAction`) یا شیء دیگری که همان رابط را پیاده‌سازی می‌کند، یک اکشندلخواه را مشخص کنید. فقط کنش‌هایی که آرگومان‌های خط فرمان را مصرف می‌کنند (برای مثال ``'store'``، ``'append'``، ``'extend'`` یا کنش‌های سفارشی با ``nargs`` غیرصفر) می‌توانند با آرگومان‌های جایگاهی استفاده شوند."

msgid "The recommended way to create a custom action is to extend :class:`Action`, overriding the :meth:`!__call__` method and optionally the :meth:`!__init__` and :meth:`!format_usage` methods. You can also register custom actions using the :meth:`~ArgumentParser.register` method and reference them by their registered name."
msgstr "روش توصیه‌شده برای ایجاد یک کنش سفارشی، گسترش :class:`Action` با بازنویسی متد :meth:`!__call__` و به‌اختیار متدهای :meth:`!__init__` و :meth:`!format_usage` است. همچنین می‌توانید کنش‌های سفارشی را با استفاده از متد :meth:`~ArgumentParser.register` ثبت کنید و با نام ثبت‌شده‌ی آن‌ها به آن‌ها ارجاع دهید."

msgid "An example of a custom action::"
msgstr "مثالی از یک اکشن سفارشی::"

msgid ""
">>> class FooAction(argparse.Action):\n"
"...     def __init__(self, option_strings, dest, nargs=None, **kwargs):\n"
"...         if nargs is not None:\n"
"...             raise ValueError(\"nargs not allowed\")\n"
"...         super().__init__(option_strings, dest, **kwargs)\n"
"...     def __call__(self, parser, namespace, values, option_string=None):\n"
"...         print('%r %r %r' % (namespace, values, option_string))\n"
"...         setattr(namespace, self.dest, values)\n"
"...\n"
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action=FooAction)\n"
">>> parser.add_argument('bar', action=FooAction)\n"
">>> args = parser.parse_args('1 --foo 2'.split())\n"
"Namespace(bar=None, foo=None) '1' None\n"
"Namespace(bar='1', foo=None) '2' '--foo'\n"
">>> args\n"
"Namespace(bar='1', foo='2')"
msgstr ""
">>> class FooAction(argparse.Action):\n"
"...     def __init__(self, option_strings, dest, nargs=None, **kwargs):\n"
"...         if nargs is not None:\n"
"...             raise ValueError(\"nargs not allowed\")\n"
"...         super().__init__(option_strings, dest, **kwargs)\n"
"...     def __call__(self, parser, namespace, values, option_string=None):\n"
"...         print('%r %r %r' % (namespace, values, option_string))\n"
"...         setattr(namespace, self.dest, values)\n"
"...\n"
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action=FooAction)\n"
">>> parser.add_argument('bar', action=FooAction)\n"
">>> args = parser.parse_args('1 --foo 2'.split())\n"
"Namespace(bar=None, foo=None) '1' None\n"
"Namespace(bar='1', foo=None) '2' '--foo'\n"
">>> args\n"
"Namespace(bar='1', foo='2')"

msgid "For more details, see :class:`Action`."
msgstr "برای جزئیات بیشتر، :class:`Action` را ببینید."

msgid "nargs"
msgstr "nargs"

msgid ":class:`ArgumentParser` objects usually associate a single command-line argument with a single action to be taken.  The ``nargs`` keyword argument associates a different number of command-line arguments with a single action. See also :ref:`specifying-ambiguous-arguments`. The supported values are:"
msgstr "اشیای :class:`ArgumentParser` معمولاً یک آرگومان خط فرمان را با یک اکشن مشخص مرتبط می‌کنند. آرگومان کلیدواژه‌ای ``nargs`` تعداد متفاوتی از آرگومان‌های خط فرمان را با یک اکشن مرتبط می‌کند. همچنین :ref:`specifying-ambiguous-arguments` را ببینید. مقادیر پشتیبانی‌شده عبارت‌اند از:"

msgid "``N`` (an integer).  ``N`` arguments from the command line will be gathered together into a list.  For example::"
msgstr "``N`` (یک عدد صحیح). ``N`` آرگومان از خط فرمان در یک فهرست جمع می‌شوند. برای مثال::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', nargs=2)\n"
">>> parser.add_argument('bar', nargs=1)\n"
">>> parser.parse_args('c --foo a b'.split())\n"
"Namespace(bar=['c'], foo=['a', 'b'])"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', nargs=2)\n"
">>> parser.add_argument('bar', nargs=1)\n"
">>> parser.parse_args('c --foo a b'.split())\n"
"Namespace(bar=['c'], foo=['a', 'b'])"

msgid "Note that ``nargs=1`` produces a list of one item.  This is different from the default, in which the item is produced by itself."
msgstr "توجه کنید که ``nargs=1`` یک فهرست با یک آیتم تولید می‌کند. این با حالت پیش‌فرض متفاوت است، که در آن آیتم به‌تنهایی تولید می‌شود."

msgid "``'?'``. One argument will be consumed from the command line if possible, and produced as a single item.  If no command-line argument is present, the value from default_ will be produced.  Note that for optional arguments, there is an additional case - the option string is present but not followed by a command-line argument.  In this case the value from const_ will be produced.  Some examples to illustrate this::"
msgstr "``'?'``. در صورت امکان، یک آرگومان از خط فرمان مصرف می‌شود و به‌عنوان یک آیتم واحد تولید می‌شود. اگر هیچ آرگومان خط فرمانی وجود نداشته باشد، مقدار default_ تولید می‌شود. توجه داشته باشید که برای آرگومان‌های اختیاری، حالت دیگری نیز وجود دارد: رشته‌ی گزینه موجود است اما آرگومان خط فرمانی پس از آن نمی‌آید. در این حالت، مقدار const_ تولید می‌شود. چند مثال برای روشن‌سازی این موضوع::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', nargs='?', const='c', default='d')\n"
">>> parser.add_argument('bar', nargs='?', default='d')\n"
">>> parser.parse_args(['XX', '--foo', 'YY'])\n"
"Namespace(bar='XX', foo='YY')\n"
">>> parser.parse_args(['XX', '--foo'])\n"
"Namespace(bar='XX', foo='c')\n"
">>> parser.parse_args([])\n"
"Namespace(bar='d', foo='d')"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', nargs='?', const='c', default='d')\n"
">>> parser.add_argument('bar', nargs='?', default='d')\n"
">>> parser.parse_args(['XX', '--foo', 'YY'])\n"
"Namespace(bar='XX', foo='YY')\n"
">>> parser.parse_args(['XX', '--foo'])\n"
"Namespace(bar='XX', foo='c')\n"
">>> parser.parse_args([])\n"
"Namespace(bar='d', foo='d')"

msgid "One of the more common uses of ``nargs='?'`` is to allow optional input and output files::"
msgstr "یکی از کاربردهای رایج‌تر ``nargs='?'``، مجاز کردن پرونده‌های ورودی و خروجی اختیاری است::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('infile', nargs='?')\n"
">>> parser.add_argument('outfile', nargs='?')\n"
">>> parser.parse_args(['input.txt', 'output.txt'])\n"
"Namespace(infile='input.txt', outfile='output.txt')\n"
">>> parser.parse_args(['input.txt'])\n"
"Namespace(infile='input.txt', outfile=None)\n"
">>> parser.parse_args([])\n"
"Namespace(infile=None, outfile=None)"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('infile', nargs='?')\n"
">>> parser.add_argument('outfile', nargs='?')\n"
">>> parser.parse_args(['input.txt', 'output.txt'])\n"
"Namespace(infile='input.txt', outfile='output.txt')\n"
">>> parser.parse_args(['input.txt'])\n"
"Namespace(infile='input.txt', outfile=None)\n"
">>> parser.parse_args([])\n"
"Namespace(infile=None, outfile=None)"

msgid "``'*'``.  All command-line arguments present are gathered into a list.  Note that it generally doesn't make much sense to have more than one positional argument with ``nargs='*'``, but multiple optional arguments with ``nargs='*'`` is possible.  For example::"
msgstr "``'*'``. تمام آرگومان‌های خط فرمان موجود در یک فهرست جمع‌آوری می‌شوند. توجه داشته باشید که معمولاً داشتن بیش از یک آرگومان جایگاهی با ``nargs='*'`` معنای چندانی ندارد، اما داشتن چند آرگومان اختیاری با ``nargs='*'`` امکان‌پذیر است. برای مثال::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', nargs='*')\n"
">>> parser.add_argument('--bar', nargs='*')\n"
">>> parser.add_argument('baz', nargs='*')\n"
">>> parser.parse_args('a b --foo x y --bar 1 2'.split())\n"
"Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y'])"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', nargs='*')\n"
">>> parser.add_argument('--bar', nargs='*')\n"
">>> parser.add_argument('baz', nargs='*')\n"
">>> parser.parse_args('a b --foo x y --bar 1 2'.split())\n"
"Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y'])"

msgid "``'+'``. Just like ``'*'``, all command-line arguments present are gathered into a list.  Additionally, an error message will be generated if there wasn't at least one command-line argument present.  For example::"
msgstr "``'+'``. درست مانند ``'*'``، تمام آرگومان‌های خط فرمانِ موجود در یک فهرست گردآوری می‌شوند. به‌علاوه، اگر حداقل یک آرگومان خط فرمان وجود نداشته باشد، یک پیام خطا تولید می‌شود. برای مثال::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('foo', nargs='+')\n"
">>> parser.parse_args(['a', 'b'])\n"
"Namespace(foo=['a', 'b'])\n"
">>> parser.parse_args([])\n"
"usage: PROG [-h] foo [foo ...]\n"
"PROG: error: the following arguments are required: foo"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('foo', nargs='+')\n"
">>> parser.parse_args(['a', 'b'])\n"
"Namespace(foo=['a', 'b'])\n"
">>> parser.parse_args([])\n"
"usage: PROG [-h] foo [foo ...]\n"
"PROG: error: the following arguments are required: foo"

msgid "If the ``nargs`` keyword argument is not provided, the number of arguments consumed is determined by the action_.  Generally this means a single command-line argument will be consumed and a single item (not a list) will be produced. Actions that do not consume command-line arguments (e.g. ``'store_const'``) set ``nargs=0``."
msgstr "اگر آرگومان کلیدواژه‌ای ``nargs`` ارائه نشده باشد، تعداد آرگومان‌های مصرف‌شده توسط action_ تعیین می‌شود. به‌طور معمول، این بدان معناست که یک آرگومان خط فرمان مصرف می‌شود و یک آیتم (نه یک فهرست) تولید می‌شود. کنش‌هایی که آرگومان‌های خط فرمان را مصرف نمی‌کنند (مانند ``'store_const'``)، ``nargs=0`` را تنظیم می‌کنند."

msgid "const"
msgstr "const"

msgid "The ``const`` argument of :meth:`~ArgumentParser.add_argument` is used to hold constant values that are not read from the command line but are required for the various :class:`ArgumentParser` actions.  The two most common uses of it are:"
msgstr "آرگومان ``const`` در :meth:`~ArgumentParser.add_argument` برای نگهداری مقادیر ثابتی استفاده می‌شود که از خط فرمان خوانده نمی‌شوند، اما برای کنش‌های مختلف :class:`ArgumentParser` مورد نیاز هستند. دو مورد از رایج‌ترین کاربردهای آن عبارت‌اند از:"

msgid "When :meth:`~ArgumentParser.add_argument` is called with ``action='store_const'`` or ``action='append_const'``.  These actions add the ``const`` value to one of the attributes of the object returned by :meth:`~ArgumentParser.parse_args`. See the action_ description for examples. If ``const`` is not provided to :meth:`~ArgumentParser.add_argument`, it will receive a default value of ``None``."
msgstr "هنگامی که :meth:`~ArgumentParser.add_argument` با ``action='store_const'`` یا ``action='append_const'`` فراخوانی می‌شود. این اکشن‌ها مقدار ``const`` را به یکی از ویژگی‌های شیء برگردانده‌شده توسط :meth:`~ArgumentParser.parse_args` اضافه می‌کنند. برای مثال‌ها، شرح action_ را ببینید. اگر ``const`` به :meth:`~ArgumentParser.add_argument` ارائه نشود، مقدار پیش‌فرض ``None`` را دریافت خواهد کرد."

msgid "When :meth:`~ArgumentParser.add_argument` is called with option strings (like ``-f`` or ``--foo``) and ``nargs='?'``.  This creates an optional argument that can be followed by zero or one command-line arguments. When parsing the command line, if the option string is encountered with no command-line argument following it, the value from ``const`` will be used. See the nargs_ description for examples."
msgstr "هنگامی که :meth:`~ArgumentParser.add_argument` با رشته‌های گزینه (مانند ``-f`` یا ``--foo``) و ``nargs='?'`` فراخوانی می‌شود، این کار یک آرگومان اختیاری ایجاد می‌کند که می‌تواند صفر یا یک آرگومان خط فرمان پس از خود داشته باشد. هنگام تجزیه خط فرمان، اگر رشته گزینه بدون هیچ آرگومان خط فرمانی پس از آن مشاهده شود، مقدار ``const`` استفاده خواهد شد. برای نمونه‌ها، توضیحات nargs_ را ببینید."

msgid "``const=None`` by default, including when ``action='append_const'`` or ``action='store_const'``."
msgstr "``const=None`` به‌طور پیش‌فرض، از جمله زمانی که ``action='append_const'`` یا ``action='store_const'`` باشد."

msgid "default"
msgstr "پیش‌فرض"

msgid "All optional arguments and some positional arguments may be omitted at the command line.  The ``default`` keyword argument of :meth:`~ArgumentParser.add_argument` specifies what value should be used if the command-line argument is not present. For example::"
msgstr "تمام آرگومان‌های اختیاری و برخی آرگومان‌های جایگاهی را می‌توان در خط فرمان حذف کرد. آرگومان کلیدواژه‌ای ``default`` تابع :meth:`~ArgumentParser.add_argument` مشخص می‌کند که اگر آرگومان خط فرمان وجود نداشته باشد، چه مقداری باید استفاده شود. برای مثال::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', default=42)\n"
">>> parser.parse_args(['--foo', '2'])\n"
"Namespace(foo='2')\n"
">>> parser.parse_args([])\n"
"Namespace(foo=42)"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', default=42)\n"
">>> parser.parse_args(['--foo', '2'])\n"
"Namespace(foo='2')\n"
">>> parser.parse_args([])\n"
"Namespace(foo=42)"

msgid "If ``default`` is omitted, :meth:`~ArgumentParser.add_argument` uses a value previously set for the dest_ with :meth:`~ArgumentParser.set_defaults`, or otherwise a non-``None`` argument_default_. If neither is set, the action's own default is used."
msgstr "اگر ``default`` حذف شود، :meth:`~ArgumentParser.add_argument` از مقداری که قبلاً برای dest_ با :meth:`~ArgumentParser.set_defaults` تنظیم شده است، یا در غیر این صورت از یک argument_default_ غیر-``None`` استفاده می‌کند. اگر هیچ‌کدام تنظیم نشده باشند، از پیش‌فرض خودِ اکشن استفاده می‌شود."

msgid "If the target namespace already has an attribute set, the action *default* will not overwrite it::"
msgstr "اگر فضای نام هدف از قبل ویژگی تنظیم‌شده‌ای داشته باشد، *پیش‌فرضِ* اکشن آن را بازنویسی نمی‌کند::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', default=42)\n"
">>> parser.parse_args([], namespace=argparse.Namespace(foo=101))\n"
"Namespace(foo=101)"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', default=42)\n"
">>> parser.parse_args([], namespace=argparse.Namespace(foo=101))\n"
"Namespace(foo=101)"

msgid "If the ``default`` value is a string, the parser parses the value as if it were a command-line argument.  In particular, the parser applies any type_ conversion argument, if provided, before setting the attribute on the :class:`Namespace` return value.  Otherwise, the parser uses the value as is::"
msgstr "اگر مقدار ``default`` یک رشته باشد، پارسر مقدار را طوری تجزیه می‌کند که گویی یک آرگومان خط فرمان باشد. به‌طور خاص، پارسر هر آرگومان تبدیل type_ را، در صورت ارائه، پیش از تنظیم ویژگی روی مقدار بازگشتی :class:`Namespace` اعمال می‌کند. در غیر این صورت، پارسر از مقدار همان‌طور که هست استفاده می‌کند::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--length', default='10', type=int)\n"
">>> parser.add_argument('--width', default=10.5, type=int)\n"
">>> parser.parse_args()\n"
"Namespace(length=10, width=10.5)"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--length', default='10', type=int)\n"
">>> parser.add_argument('--width', default=10.5, type=int)\n"
">>> parser.parse_args()\n"
"Namespace(length=10, width=10.5)"

msgid "For positional arguments with nargs_ equal to ``?`` or ``*``, the ``default`` value is used when no command-line argument was present::"
msgstr "برای آرگومان‌های جایگاهی که nargs_ آن‌ها برابر با ``?`` یا ``*`` است، هرگاه هیچ آرگومانی در خط فرمان وجود نداشته باشد، از مقدار ``default`` استفاده می‌شود::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('foo', nargs='?', default=42)\n"
">>> parser.parse_args(['a'])\n"
"Namespace(foo='a')\n"
">>> parser.parse_args([])\n"
"Namespace(foo=42)"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('foo', nargs='?', default=42)\n"
">>> parser.parse_args(['a'])\n"
"Namespace(foo='a')\n"
">>> parser.parse_args([])\n"
"Namespace(foo=42)"

msgid "Because ``nargs='*'`` gathers any supplied values into a list, an absent positional argument yields an empty list (``[]``). Only a non-``None`` *default* overrides this (so ``default=None`` still gives ``[]``)."
msgstr "از آنجا که ``nargs='*'`` همه مقادیر ارائه‌شده را در یک فهرست جمع می‌کند، در نبود یک آرگومان جایگاهی، یک فهرست خالی (``[]``) برگردانده می‌شود. تنها یک *پیش‌فرض* غیر ``None`` این رفتار را بازنویسی می‌کند (بنابراین ``default=None`` همچنان ``[]`` برمی‌گرداند)."

msgid "For required_ arguments, the ``default`` value is ignored. For example, this applies to positional arguments with nargs_ values other than ``?`` or ``*``, or optional arguments marked as ``required=True``."
msgstr "برای آرگومان‌های required_، مقدار ``default`` نادیده گرفته می‌شود. برای مثال، این موضوع به آرگومان‌های جایگاهی با مقادیر nargs_ غیر از ``?`` یا ``*``، یا آرگومان‌های اختیاری که با ``required=True`` علامت‌گذاری شده‌اند اعمال می‌شود."

msgid "Providing ``default=argparse.SUPPRESS`` causes no attribute to be added if the command-line argument was not present::"
msgstr "با ارائه ``default=argparse.SUPPRESS``، اگر آرگومان خط فرمان وجود نداشته باشد، هیچ ویژگی‌ای اضافه نمی‌شود::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', default=argparse.SUPPRESS)\n"
">>> parser.parse_args([])\n"
"Namespace()\n"
">>> parser.parse_args(['--foo', '1'])\n"
"Namespace(foo='1')"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', default=argparse.SUPPRESS)\n"
">>> parser.parse_args([])\n"
"Namespace()\n"
">>> parser.parse_args(['--foo', '1'])\n"
"Namespace(foo='1')"

msgid "type"
msgstr "نوع"

msgid "By default, the parser reads command-line arguments in as simple strings. However, quite often the command-line string should instead be interpreted as another type, such as a :class:`float` or :class:`int`.  The ``type`` keyword for :meth:`~ArgumentParser.add_argument` allows any necessary type-checking and type conversions to be performed."
msgstr "به‌طور پیش‌فرض، پارسر آرگومان‌های خط فرمان را به‌صورت رشته‌های ساده می‌خواند. با این حال، اغلب رشته‌ی خط فرمان باید به‌جای آن به‌عنوان نوع دیگری تفسیر شود، مانند :class:`float` یا :class:`int`. کلیدواژه‌ی ``type`` برای :meth:`~ArgumentParser.add_argument` امکان انجام هرگونه بررسی نوع و تبدیل نوع ضروری را فراهم می‌کند."

msgid "If the type_ keyword is used with the default_ keyword, the type converter is only applied if the default is a string."
msgstr "اگر از کلیدواژه‌ی type_ همراه با کلیدواژه‌ی default_ استفاده شود، مبدل نوع فقط زمانی اعمال می‌شود که مقدار پیش‌فرض یک رشته باشد."

msgid "The argument to ``type`` can be a callable that accepts a single string or the name of a registered type (see :meth:`~ArgumentParser.register`) If the function raises :exc:`ArgumentTypeError`, :exc:`TypeError`, or :exc:`ValueError`, the exception is caught and a nicely formatted error message is displayed. Other exception types are not handled."
msgstr "آرگومان ``type`` می‌تواند یک شیء فراخوانی‌پذیر باشد که یک رشته واحد را می‌پذیرد، یا نام یک نوع ثبت‌شده (به :meth:`~ArgumentParser.register` مراجعه کنید). اگر تابع :exc:`ArgumentTypeError`، :exc:`TypeError` یا :exc:`ValueError` را پرتاب کند، استثنا گرفته می‌شود و یک پیام خطای به‌خوبی قالب‌بندی‌شده نمایش داده می‌شود. سایر انواع استثنا مدیریت نمی‌شوند."

msgid "Common built-in types and functions can be used as type converters:"
msgstr "می‌توان از انواع و توابع توکار رایج به‌عنوان مبدل‌های نوع استفاده کرد:"

msgid ""
"import argparse\n"
"import pathlib\n"
"\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument('count', type=int)\n"
"parser.add_argument('distance', type=float)\n"
"parser.add_argument('street', type=ascii)\n"
"parser.add_argument('code_point', type=ord)\n"
"parser.add_argument('datapath', type=pathlib.Path)"
msgstr ""
"import argparse\n"
"import pathlib\n"
"\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument('count', type=int)\n"
"parser.add_argument('distance', type=float)\n"
"parser.add_argument('street', type=ascii)\n"
"parser.add_argument('code_point', type=ord)\n"
"parser.add_argument('datapath', type=pathlib.Path)"

msgid "User defined functions can be used as well:"
msgstr "می‌توان از توابع تعریف‌شده توسط کاربر نیز استفاده کرد:"

msgid ""
">>> def hyphenated(string):\n"
"...     return '-'.join([word[:4] for word in string.casefold().split()])\n"
"...\n"
">>> parser = argparse.ArgumentParser()\n"
">>> _ = parser.add_argument('short_title', type=hyphenated)\n"
">>> parser.parse_args(['\"The Tale of Two Cities\"'])\n"
"Namespace(short_title='\"the-tale-of-two-citi')"
msgstr ""
">>> def hyphenated(string):\n"
"...     return '-'.join([word[:4] for word in string.casefold().split()])\n"
"...\n"
">>> parser = argparse.ArgumentParser()\n"
">>> _ = parser.add_argument('short_title', type=hyphenated)\n"
">>> parser.parse_args(['\"The Tale of Two Cities\"'])\n"
"Namespace(short_title='\"the-tale-of-two-citi')"

msgid "The :func:`bool` function is not recommended as a type converter.  All it does is convert empty strings to ``False`` and non-empty strings to ``True``. This is usually not what is desired::"
msgstr "تابع :func:`bool` به‌عنوان مبدل نوع توصیه نمی‌شود. تنها کاری که انجام می‌دهد تبدیل رشته‌های خالی به ``False`` و رشته‌های غیرخالی به ``True`` است. این معمولاً آنچه مطلوب است نیست::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> _ = parser.add_argument('--verbose', type=bool)\n"
">>> parser.parse_args(['--verbose', 'False'])\n"
"Namespace(verbose=True)"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> _ = parser.add_argument('--verbose', type=bool)\n"
">>> parser.parse_args(['--verbose', 'False'])\n"
"Namespace(verbose=True)"

msgid "See :class:`BooleanOptionalAction` or ``action='store_true'`` for common alternatives."
msgstr "برای جایگزین‌های رایج، :class:`BooleanOptionalAction` یا ``action='store_true'`` را ببینید."

msgid "In general, the ``type`` keyword is a convenience that should only be used for simple conversions that can only raise one of the three supported exceptions. Anything with more interesting error-handling or resource management should be done downstream after the arguments are parsed."
msgstr "به‌طور کلی، آرگومان کلیدواژه‌ای ``type`` برای سهولت در نظر گرفته شده است و باید فقط برای تبدیل‌های ساده‌ای به کار رود که تنها می‌توانند یکی از سه استثنای پشتیبانی‌شده را پرتاب کنند. هر موردی که مدیریت خطا یا مدیریت منابع پیچیده‌تری دارد، باید پس از تجزیه‌ی آرگومان‌ها در مراحل بعدی انجام شود."

msgid "For example, JSON or YAML conversions have complex error cases that require better reporting than can be given by the ``type`` keyword.  A :exc:`~json.JSONDecodeError` would not be well formatted and a :exc:`FileNotFoundError` exception would not be handled at all."
msgstr "برای مثال، تبدیل‌های JSON یا YAML دارای موارد خطای پیچیده‌ای هستند که به گزارش‌دهی بهتری نسبت به آنچه کلیدواژه ``type`` می‌تواند ارائه کند نیاز دارند. یک :exc:`~json.JSONDecodeError` به‌درستی قالب‌بندی نمی‌شد و استثنای :exc:`FileNotFoundError` به‌هیچ‌وجه مدیریت نمی‌شد."

msgid "Even :class:`~argparse.FileType` has its limitations for use with the ``type`` keyword.  If one argument uses :class:`~argparse.FileType` and then a subsequent argument fails, an error is reported but the file is not automatically closed.  In this case, it would be better to wait until after the parser has run and then use the :keyword:`with`-statement to manage the files."
msgstr "حتی :class:`~argparse.FileType` برای استفاده با کلیدواژه‌ی ``type`` محدودیت‌هایی دارد. اگر یک آرگومان از :class:`~argparse.FileType` استفاده کند و سپس آرگومان بعدی با شکست مواجه شود، خطایی گزارش می‌شود اما پرونده به‌طور خودکار بسته نمی‌شود. در این صورت، بهتر است تا پایان اجرای پارسر صبر کنید و سپس از دستور :keyword:`with` برای مدیریت پرونده‌ها استفاده کنید."

msgid "For type checkers that simply check against a fixed set of values, consider using the choices_ keyword instead."
msgstr "برای ابزارهای بررسی نوع که صرفاً در برابر مجموعه ثابتی از مقادیر بررسی می‌کنند، استفاده از کلیدواژه choices_ را به‌جای آن در نظر بگیرید."

msgid "choices"
msgstr "گزینه‌ها"

msgid "Some command-line arguments should be selected from a restricted set of values. These can be handled by passing a sequence object as the *choices* keyword argument to :meth:`~ArgumentParser.add_argument`.  When the command line is parsed, argument values will be checked, and an error message will be displayed if the argument was not one of the acceptable values::"
msgstr "برخی آرگومان‌های خط فرمان باید از میان یک مجموعه محدود از مقدارها انتخاب شوند. این موارد را می‌توان با ارسال یک شیء دنباله به‌عنوان آرگومان کلیدواژه‌ای *choices* به :meth:`~ArgumentParser.add_argument` مدیریت کرد. هنگامی که خط فرمان تجزیه می‌شود، مقدارهای آرگومان بررسی خواهند شد و اگر آرگومان یکی از مقدارهای قابل‌قبول نباشد، یک پیام خطا نمایش داده می‌شود::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='game.py')\n"
">>> parser.add_argument('move', choices=['rock', 'paper', 'scissors'])\n"
">>> parser.parse_args(['rock'])\n"
"Namespace(move='rock')\n"
">>> parser.parse_args(['fire'])\n"
"usage: game.py [-h] {rock,paper,scissors}\n"
"game.py: error: argument move: invalid choice: 'fire' (choose from 'rock',\n"
"'paper', 'scissors')"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='game.py')\n"
">>> parser.add_argument('move', choices=['rock', 'paper', 'scissors'])\n"
">>> parser.parse_args(['rock'])\n"
"Namespace(move='rock')\n"
">>> parser.parse_args(['fire'])\n"
"usage: game.py [-h] {rock,paper,scissors}\n"
"game.py: error: argument move: invalid choice: 'fire' (choose from 'rock',\n"
"'paper', 'scissors')"

msgid "Any sequence can be passed as the *choices* value, so :class:`list` objects, :class:`tuple` objects, and custom sequences are all supported."
msgstr "هر دنباله‌ای را می‌توان به‌عنوان مقدار *choices* ارسال کرد، بنابراین اشیای :class:`list`، اشیای :class:`tuple` و دنباله‌های سفارشی همگی پشتیبانی می‌شوند."

msgid "Use of :class:`enum.Enum` is not recommended because it is difficult to control its appearance in usage, help, and error messages."
msgstr "استفاده از :class:`enum.Enum` توصیه نمی‌شود، زیرا کنترل نحوه‌ی نمایش آن در کاربرد، راهنما و پیام‌های خطا دشوار است."

msgid "Note that *choices* are checked after any type_ conversions have been performed, so objects in *choices* should match the type_ specified. This can make *choices* appear unfamiliar in usage, help, or error messages."
msgstr "توجه داشته باشید که *choices* پس از انجام هرگونه تبدیل type_ بررسی می‌شوند، بنابراین اشیاء موجود در *choices* باید با type_ مشخص‌شده مطابقت داشته باشند. این موضوع می‌تواند باعث شود *choices* در نحوه استفاده، راهنما یا پیام‌های خطا ناآشنا به نظر برسد."

msgid "To keep *choices* user-friendly, consider a custom type wrapper that converts and formats values, or omit type_ and handle conversion in your application code."
msgstr "برای کاربرپسند نگه‌داشتن *choices*، پوششی سفارشی برای نوع در نظر بگیرید که مقادیر را تبدیل و قالب‌بندی می‌کند، یا type_ را حذف کنید و تبدیل را در کد برنامه‌تان مدیریت کنید."

msgid "Formatted choices override the default *metavar* which is normally derived from *dest*.  This is usually what you want because the user never sees the *dest* parameter.  If this display isn't desirable (perhaps because there are many choices), just specify an explicit metavar_."
msgstr "گزینه‌های قالب‌بندی‌شده به‌جای *metavar* پیش‌فرض، که معمولاً از *dest* مشتق می‌شود، استفاده می‌شوند. این معمولاً همان چیزی است که شما می‌خواهید، زیرا کاربر هرگز پارامتر *dest* را نمی‌بیند. اگر این نمایش مطلوب نیست (شاید به این دلیل که گزینه‌های زیادی وجود دارد)، کافی است یک metavar_ صریح مشخص کنید."

msgid "required"
msgstr "الزامی"

msgid "In general, the :mod:`!argparse` module assumes that flags like ``-f`` and ``--bar`` indicate *optional* arguments, which can always be omitted at the command line. To make an option *required*, ``True`` can be specified for the ``required=`` keyword argument to :meth:`~ArgumentParser.add_argument`::"
msgstr "به‌طور کلی، ماژول :mod:`!argparse` فرض می‌کند که پرچم‌هایی مانند ``-f`` و ``--bar`` نشان‌دهنده‌ی آرگومان‌های *اختیاری* هستند که همیشه می‌توان در خط فرمان از آن‌ها صرف‌نظر کرد. برای *الزامی* کردن یک گزینه، می‌توان ``True`` را برای آرگومان کلیدواژه‌ای ``required=`` در :meth:`~ArgumentParser.add_argument` مشخص کرد::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', required=True)\n"
">>> parser.parse_args(['--foo', 'BAR'])\n"
"Namespace(foo='BAR')\n"
">>> parser.parse_args([])\n"
"usage: [-h] --foo FOO\n"
": error: the following arguments are required: --foo"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', required=True)\n"
">>> parser.parse_args(['--foo', 'BAR'])\n"
"Namespace(foo='BAR')\n"
">>> parser.parse_args([])\n"
"usage: [-h] --foo FOO\n"
": error: the following arguments are required: --foo"

msgid "As the example shows, if an option is marked as ``required``, :meth:`~ArgumentParser.parse_args` will report an error if that option is not present at the command line."
msgstr "همان‌طور که مثال نشان می‌دهد، اگر یک گزینه به‌عنوان ``required`` علامت‌گذاری شده باشد، :meth:`~ArgumentParser.parse_args` در صورتی که آن گزینه در خط فرمان وجود نداشته باشد، خطایی گزارش خواهد کرد."

msgid "Required options are generally considered bad form because users expect *options* to be *optional*, and thus they should be avoided when possible."
msgstr "گزینه‌های الزامی عموماً نامناسب تلقی می‌شوند، زیرا کاربران انتظار دارند *گزینه‌ها* *اختیاری* باشند؛ بنابراین باید در صورت امکان از آن‌ها اجتناب شود."

msgid "help"
msgstr "راهنما"

msgid "The ``help`` value is a string containing a brief description of the argument. When a user requests help (usually by using ``-h`` or ``--help`` at the command line), these ``help`` descriptions will be displayed with each argument."
msgstr "مقدار ``help`` یک رشته است که شامل توضیحی مختصر در مورد آرگومان می‌شود. هنگامی که کاربر درخواست راهنما می‌کند (معمولاً با استفاده از ``-h`` یا ``--help`` در خط فرمان)، این توضیحات ``help`` همراه با هر آرگومان نمایش داده خواهند شد."

msgid "The ``help`` strings can include various format specifiers to avoid repetition of things like the program name or the argument default_.  The available specifiers include the program name, ``%(prog)s`` and most keyword arguments to :meth:`~ArgumentParser.add_argument`, e.g. ``%(default)s``, ``%(type)s``, etc.::"
msgstr "رشته‌های ``help`` می‌توانند شامل مشخص‌کننده‌های قالب مختلفی باشند تا از تکرار مواردی مانند نام برنامه یا default_ آرگومان جلوگیری شود. مشخص‌کننده‌های موجود شامل نام برنامه، ``%(prog)s`` و بیشتر آرگومان‌های کلیدواژه‌ای :meth:`~ArgumentParser.add_argument` هستند، برای مثال ``%(default)s``، ``%(type)s`` و غیره.::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='frobble')\n"
">>> parser.add_argument('bar', nargs='?', type=int, default=42,\n"
"...                     help='the bar to %(prog)s (default: %(default)s)')\n"
">>> parser.print_help()\n"
"usage: frobble [-h] [bar]\n"
"\n"
"positional arguments:\n"
" bar     the bar to frobble (default: 42)\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='frobble')\n"
">>> parser.add_argument('bar', nargs='?', type=int, default=42,\n"
"...                     help='the bar to %(prog)s (default: %(default)s)')\n"
">>> parser.print_help()\n"
"usage: frobble [-h] [bar]\n"
"\n"
"positional arguments:\n"
" bar     the bar to frobble (default: 42)\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit"

msgid "As the help string supports %-formatting, if you want a literal ``%`` to appear in the help string, you must escape it as ``%%``."
msgstr "از آن‌جا که رشته راهنما از قالب‌بندی % پشتیبانی می‌کند، اگر می‌خواهید یک ``%`` به‌صورت لفظی در رشته راهنما ظاهر شود، باید آن را به‌صورت ``%%`` خنثی کنید."

msgid ":mod:`!argparse` supports silencing the help entry for certain options, by setting the ``help`` value to ``argparse.SUPPRESS``::"
msgstr ":mod:`!argparse` از پنهان کردن ورودی راهنما برای برخی گزینه‌ها، با تنظیم مقدار ``help`` بر روی ``argparse.SUPPRESS`` پشتیبانی می‌کند::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='frobble')\n"
">>> parser.add_argument('--foo', help=argparse.SUPPRESS)\n"
">>> parser.print_help()\n"
"usage: frobble [-h]\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='frobble')\n"
">>> parser.add_argument('--foo', help=argparse.SUPPRESS)\n"
">>> parser.print_help()\n"
"usage: frobble [-h]\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit"

msgid "metavar"
msgstr "metavar"

msgid "When :class:`ArgumentParser` generates help messages, it needs some way to refer to each expected argument.  By default, :class:`!ArgumentParser` objects use the dest_ value as the \"name\" of each object.  By default, for positional argument actions, the dest_ value is used directly, and for optional argument actions, the dest_ value is uppercased.  So, a single positional argument with ``dest='bar'`` will be referred to as ``bar``. A single optional argument ``--foo`` that should be followed by a single command-line argument will be referred to as ``FOO``.  An example::"
msgstr "هنگامی که :class:`ArgumentParser` پیام‌های راهنما را تولید می‌کند، به روشی برای ارجاع به هر آرگومان مورد انتظار نیاز دارد. به‌طور پیش‌فرض، اشیاء :class:`!ArgumentParser` از مقدار dest_ به‌عنوان «نام» هر شیء استفاده می‌کنند. به‌طور پیش‌فرض، برای کنش‌های آرگومان‌های جایگاهی، مقدار dest_ مستقیماً استفاده می‌شود، و برای کنش‌های آرگومان‌های اختیاری، مقدار dest_ به حروف بزرگ تبدیل می‌شود. بنابراین، یک آرگومان جایگاهی با ``dest='bar'``، ``bar`` نامیده می‌شود. یک آرگومان اختیاری ``--foo`` که باید یک آرگومان خط فرمان به دنبال آن بیاید، ``FOO`` نامیده می‌شود. یک مثال::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo')\n"
">>> parser.add_argument('bar')\n"
">>> parser.parse_args('X --foo Y'.split())\n"
"Namespace(bar='X', foo='Y')\n"
">>> parser.print_help()\n"
"usage:  [-h] [--foo FOO] bar\n"
"\n"
"positional arguments:\n"
" bar\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" --foo FOO"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo')\n"
">>> parser.add_argument('bar')\n"
">>> parser.parse_args('X --foo Y'.split())\n"
"Namespace(bar='X', foo='Y')\n"
">>> parser.print_help()\n"
"usage:  [-h] [--foo FOO] bar\n"
"\n"
"positional arguments:\n"
" bar\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" --foo FOO"

msgid "An alternative name can be specified with ``metavar``::"
msgstr "می‌توان یک نام جایگزین را با ``metavar`` مشخص کرد::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', metavar='YYY')\n"
">>> parser.add_argument('bar', metavar='XXX')\n"
">>> parser.parse_args('X --foo Y'.split())\n"
"Namespace(bar='X', foo='Y')\n"
">>> parser.print_help()\n"
"usage:  [-h] [--foo YYY] XXX\n"
"\n"
"positional arguments:\n"
" XXX\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" --foo YYY"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', metavar='YYY')\n"
">>> parser.add_argument('bar', metavar='XXX')\n"
">>> parser.parse_args('X --foo Y'.split())\n"
"Namespace(bar='X', foo='Y')\n"
">>> parser.print_help()\n"
"usage:  [-h] [--foo YYY] XXX\n"
"\n"
"positional arguments:\n"
" XXX\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" --foo YYY"

msgid "Note that ``metavar`` only changes the *displayed* name - the name of the attribute on the :meth:`~ArgumentParser.parse_args` object is still determined by the dest_ value."
msgstr "توجه داشته باشید که ``metavar`` فقط نام *نمایش‌داده‌شده* را تغییر می‌دهد — نام ویژگی در شیء :meth:`~ArgumentParser.parse_args` همچنان توسط مقدار dest_ تعیین می‌شود."

msgid "Different values of ``nargs`` may cause the metavar to be used multiple times. Providing a tuple to ``metavar`` specifies a different display for each of the arguments::"
msgstr "مقادیر مختلف ``nargs`` ممکن است باعث شود metavar چندین بار استفاده شود. ارائه یک تاپل به ``metavar`` نمایش متفاوتی را برای هر یک از آرگومان‌ها مشخص می‌کند::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-x', nargs=2)\n"
">>> parser.add_argument('--foo', nargs=2, metavar=('bar', 'baz'))\n"
">>> parser.print_help()\n"
"usage: PROG [-h] [-x X X] [--foo bar baz]\n"
"\n"
"options:\n"
" -h, --help     show this help message and exit\n"
" -x X X\n"
" --foo bar baz"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-x', nargs=2)\n"
">>> parser.add_argument('--foo', nargs=2, metavar=('bar', 'baz'))\n"
">>> parser.print_help()\n"
"usage: PROG [-h] [-x X X] [--foo bar baz]\n"
"\n"
"options:\n"
" -h, --help     show this help message and exit\n"
" -x X X\n"
" --foo bar baz"

msgid "dest"
msgstr "dest"

msgid "Most :class:`ArgumentParser` actions add some value as an attribute of the object returned by :meth:`~ArgumentParser.parse_args`.  The name of this attribute is determined by the ``dest`` keyword argument of :meth:`~ArgumentParser.add_argument`.  For positional argument actions, ``dest`` is normally supplied as the first argument to :meth:`~ArgumentParser.add_argument`::"
msgstr "بیشتر کنش‌های :class:`ArgumentParser` مقداری را به‌عنوان ویژگی‌ای از شیء برگردانده‌شده از :meth:`~ArgumentParser.parse_args` می‌افزایند. نام این ویژگی با آرگومان کلیدواژه‌ای ``dest`` در :meth:`~ArgumentParser.add_argument` تعیین می‌شود. برای کنش‌های آرگومان‌های جایگاهی، ``dest`` معمولاً به‌عنوان اولین آرگومان به :meth:`~ArgumentParser.add_argument` داده می‌شود::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('bar')\n"
">>> parser.parse_args(['XXX'])\n"
"Namespace(bar='XXX')"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('bar')\n"
">>> parser.parse_args(['XXX'])\n"
"Namespace(bar='XXX')"

msgid "For optional argument actions, the value of ``dest`` is normally inferred from the option strings.  :class:`ArgumentParser` generates the value of ``dest`` by taking the first double-dash long option string and stripping away the initial ``-`` characters. If no double-dash long option strings were supplied, ``dest`` will be derived from the first single-dash long option string by stripping the initial ``-`` character. If no long option strings were supplied, ``dest`` will be derived from the first short option string by stripping the initial ``-`` character.  Any internal ``-`` characters will be converted to ``_`` characters to make sure the string is a valid attribute name.  The examples below illustrate this behavior::"
msgstr "برای اکشن‌های آرگومان اختیاری، مقدار ``dest`` معمولاً از رشته‌های گزینه استنباط می‌شود. کلاس :class:`ArgumentParser` مقدار ``dest`` را با گرفتن نخستین رشته‌ی گزینه طولانی دوخط‌تیره‌ای و حذف نویسه‌های اولیه‌ی ``-`` تولید می‌کند. اگر هیچ رشته‌ی گزینه‌ی طولانی دوخط‌تیره‌ای ارائه نشده باشد، ``dest`` از نخستین رشته‌ی گزینه‌ی طولانی تک‌خط‌تیره‌ای با حذف نویسه‌ی اولیه‌ی ``-`` مشتق خواهد شد. اگر هیچ رشته‌ی گزینه‌ی طولانی ارائه نشده باشد، ``dest`` از نخستین رشته‌ی گزینه‌ی کوتاه با حذف نویسه‌ی اولیه‌ی ``-`` مشتق خواهد شد. هر گونه نویسه‌ی داخلی ``-`` به نویسه‌های ``_`` تبدیل خواهد شد تا مطمئن شویم رشته یک نام ویژگی معتبر است. مثال‌های زیر این رفتار را نشان می‌دهند::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('-f', '--foo-bar', '--foo')\n"
">>> parser.add_argument('-q', '-quz')\n"
">>> parser.add_argument('-x', '-y')\n"
">>> parser.parse_args('-f 1 -q 2 -x 3'.split())\n"
"Namespace(foo_bar='1', quz='2', x='3')\n"
">>> parser.parse_args('--foo 1 -quz 2 -y 3'.split())\n"
"Namespace(foo_bar='1', quz='2', x='2')"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('-f', '--foo-bar', '--foo')\n"
">>> parser.add_argument('-q', '-quz')\n"
">>> parser.add_argument('-x', '-y')\n"
">>> parser.parse_args('-f 1 -q 2 -x 3'.split())\n"
"Namespace(foo_bar='1', quz='2', x='3')\n"
">>> parser.parse_args('--foo 1 -quz 2 -y 3'.split())\n"
"Namespace(foo_bar='1', quz='2', x='2')"

msgid "``dest`` allows a custom attribute name to be provided::"
msgstr "``dest`` امکان ارائه‌ی یک نام ویژگی سفارشی را فراهم می‌کند::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', dest='bar')\n"
">>> parser.parse_args('--foo XXX'.split())\n"
"Namespace(bar='XXX')"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', dest='bar')\n"
">>> parser.parse_args('--foo XXX'.split())\n"
"Namespace(bar='XXX')"

msgid "Multiple arguments may share the same ``dest``.  By default, the value from the last such argument given on the command line wins.  Use ``action='append'`` to collect values from all of them into a list instead.  For conflicting *option strings* rather than ``dest`` names, see conflict_handler_."
msgstr "آرگومان‌های متعدد می‌توانند ``dest`` یکسانی داشته باشند. به‌صورت پیش‌فرض، مقدار آخرین آرگومان از این نوع که در خط فرمان وارد شود، برنده می‌شود. در عوض، برای جمع‌آوری مقادیر همه‌ی آن‌ها در یک فهرست، از ``action='append'`` استفاده کنید. برای *رشته‌های گزینه* دارای تعارض، نه نام‌های ``dest``، conflict_handler_ را ببینید."

msgid "Single-dash long option now takes precedence over short options."
msgstr "گزینه‌ی طولانی با یک خط تیره اکنون نسبت به گزینه‌های کوتاه اولویت دارد."

msgid "deprecated"
msgstr "منسوخ"

msgid "During a project's lifetime, some arguments may need to be removed from the command line. Before removing them, you should inform your users that the arguments are deprecated and will be removed. The ``deprecated`` keyword argument of :meth:`~ArgumentParser.add_argument`, which defaults to ``False``, specifies if the argument is deprecated and will be removed in the future. For arguments, if ``deprecated`` is ``True``, then a warning will be printed to :data:`sys.stderr` when the argument is used::"
msgstr "در طول عمر یک پروژه، ممکن است نیاز باشد برخی آرگومان‌ها از خط فرمان حذف شوند. پیش از حذف آن‌ها، باید به کاربران خود اطلاع دهید که آرگومان‌ها منسوخ شده‌اند و حذف خواهند شد. آرگومان کلیدواژه‌ای ``deprecated`` در :meth:`~ArgumentParser.add_argument`، که مقدار پیش‌فرض آن ``False`` است، مشخص می‌کند که آیا آرگومان منسوخ است و در آینده حذف خواهد شد یا خیر. برای آرگومان‌ها، اگر ``deprecated`` برابر ``True`` باشد، هنگام استفاده از آرگومان، هشداری در :data:`sys.stderr` چاپ می‌شود::"

msgid ""
">>> import argparse\n"
">>> parser = argparse.ArgumentParser(prog='snake.py')\n"
">>> parser.add_argument('--legs', default=0, type=int, deprecated=True)\n"
">>> parser.parse_args([])\n"
"Namespace(legs=0)\n"
">>> parser.parse_args(['--legs', '4'])\n"
"snake.py: warning: option '--legs' is deprecated\n"
"Namespace(legs=4)"
msgstr ""
">>> import argparse\n"
">>> parser = argparse.ArgumentParser(prog='snake.py')\n"
">>> parser.add_argument('--legs', default=0, type=int, deprecated=True)\n"
">>> parser.parse_args([])\n"
"Namespace(legs=0)\n"
">>> parser.parse_args(['--legs', '4'])\n"
"snake.py: warning: option '--legs' is deprecated\n"
"Namespace(legs=4)"

msgid "Action classes"
msgstr "کلاس‌های اکشن"

msgid ":class:`!Action` classes implement the Action API, a callable which returns a callable which processes arguments from the command-line. Any object which follows this API may be passed as the ``action`` parameter to :meth:`~ArgumentParser.add_argument`."
msgstr "کلاس‌های :class:`!Action`، Action API را پیاده‌سازی می‌کنند؛ یک فراخوانی‌پذیر که یک فراخوانی‌پذیر برای پردازش آرگومان‌های خط فرمان بازمی‌گرداند. هر شیء‌ای که از این API پیروی کند، می‌تواند به‌عنوان پارامتر ``action`` به :meth:`~ArgumentParser.add_argument` ارسال شود."

msgid ":class:`!Action` objects are used by an :class:`ArgumentParser` to represent the information needed to parse a single argument from one or more strings from the command line. The :class:`!Action` class must accept the two positional arguments plus any keyword arguments passed to :meth:`ArgumentParser.add_argument` except for the ``action`` itself."
msgstr "اشیای :class:`!Action` توسط یک :class:`ArgumentParser` برای نشان دادن اطلاعات مورد نیاز برای تجزیه‌ی یک آرگومان از یک یا چند رشته از خط فرمان به کار می‌روند. کلاس :class:`!Action` باید دو آرگومان جایگاهی به‌همراه هر آرگومان کلیدواژه‌ای که به :meth:`ArgumentParser.add_argument` ارسال می‌شود، به‌جز خود ``action``، بپذیرد."

msgid "Instances of :class:`!Action` (or return value of any callable to the ``action`` parameter) should have attributes :attr:`!dest`, :attr:`!option_strings`, :attr:`!default`, :attr:`!type`, :attr:`!required`, :attr:`!help`, etc. defined. The easiest way to ensure these attributes are defined is to call :meth:`!Action.__init__`."
msgstr "در نمونه‌های :class:`!Action` (یا مقدار بازگشتی هر فراخوانی‌پذیر که به پارامتر ``action`` داده شود) باید ویژگی‌های :attr:`!dest`، :attr:`!option_strings`، :attr:`!default`، :attr:`!type`، :attr:`!required`، :attr:`!help` و غیره تعریف‌شده باشند. ساده‌ترین راه برای اطمینان از تعریف این ویژگی‌ها، فراخوانی :meth:`!Action.__init__` است."

msgid ":class:`!Action` instances should be callable, so subclasses must override the :meth:`!__call__` method, which should accept four parameters:"
msgstr "نمونه‌های :class:`!Action` باید فراخوانی‌پذیر باشند، بنابراین زیرکلاس‌ها باید متد :meth:`!__call__` را بازنویسی کنند، که باید چهار پارامتر بپذیرد:"

msgid "*parser* - The :class:`ArgumentParser` object which contains this action."
msgstr "*parser* - شیء :class:`ArgumentParser` که شامل این اکشناست."

msgid "*namespace* - The :class:`Namespace` object that will be returned by :meth:`~ArgumentParser.parse_args`.  Most actions add an attribute to this object using :func:`setattr`."
msgstr "*namespace* - شیء :class:`Namespace` که توسط :meth:`~ArgumentParser.parse_args` بازگردانده می‌شود. بیشتر اکشن‌ها با استفاده از :func:`setattr` یک ویژگی به این شیء اضافه می‌کنند."

msgid "*values* - The associated command-line arguments, with any type conversions applied.  Type conversions are specified with the type_ keyword argument to :meth:`~ArgumentParser.add_argument`."
msgstr "*values* - آرگومان‌های مرتبط با خط فرمان، با هرگونه تبدیل نوع اعمال‌شده. تبدیل‌های نوع با آرگومان کلیدواژه‌ای type_ در :meth:`~ArgumentParser.add_argument` مشخص می‌شوند."

msgid "*option_string* - The option string that was used to invoke this action. The ``option_string`` argument is optional, and will be absent if the action is associated with a positional argument."
msgstr "*option_string* - رشته‌ی گزینه‌ای که برای فراخوانی این عمل استفاده شده است. آرگومان ``option_string`` اختیاری است و اگر اکشن با یک آرگومان جایگاهی مرتبط باشد، وجود نخواهد داشت."

msgid "The :meth:`!__call__` method may perform arbitrary actions, but will typically set attributes on the ``namespace`` based on ``dest`` and ``values``."
msgstr "متد :meth:`!__call__` ممکن است عملیات دلخواهی انجام دهد، اما معمولاً ویژگی‌هایی را روی ``namespace`` بر اساس ``dest`` و ``values`` تنظیم می‌کند."

msgid ":class:`!Action` subclasses can define a :meth:`!format_usage` method that takes no argument and return a string which will be used when printing the usage of the program. If such method is not provided, a sensible default will be used."
msgstr "زیرکلاس‌های :class:`!Action` می‌توانند یک متد :meth:`!format_usage` تعریف کنند که هیچ آرگومانی نمی‌گیرد و رشته‌ای را برمی‌گرداند که هنگام چاپ کاربرد برنامه استفاده خواهد شد. اگر چنین متدی ارائه نشود، از یک پیش‌فرض مناسب استفاده خواهد شد."

msgid "A subclass of :class:`Action` for handling boolean flags with positive and negative options. Adding a single argument such as ``--foo`` automatically creates both ``--foo`` and ``--no-foo`` options, storing ``True`` and ``False`` respectively::"
msgstr "زیرکلاسی از :class:`Action` برای مدیریت پرچم‌های بولی با گزینه‌های مثبت و منفی. افزودن یک آرگومان مانند ``--foo`` به‌طور خودکار هر دو گزینه‌ی ``--foo`` و ``--no-foo`` را ایجاد می‌کند که به‌ترتیب ``True`` و ``False`` را ذخیره می‌کنند::"

msgid ""
">>> import argparse\n"
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action=argparse.BooleanOptionalAction)\n"
">>> parser.parse_args(['--no-foo'])\n"
"Namespace(foo=False)"
msgstr ""
">>> import argparse\n"
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action=argparse.BooleanOptionalAction)\n"
">>> parser.parse_args(['--no-foo'])\n"
"Namespace(foo=False)"

msgid "Single-dash long options are also supported. For example, negative option ``-nofoo`` is automatically added for positive option ``-foo``. But no additional options are added for short options such as ``-f``."
msgstr "گزینه‌های طولانی با یک خط تیره نیز پشتیبانی می‌شوند. برای مثال، گزینه‌ی منفی ``-nofoo`` به‌طور خودکار برای گزینه‌ی مثبت ``-foo`` اضافه می‌شود. اما هیچ گزینه‌ی اضافه‌ای برای گزینه‌های کوتاهی مانند ``-f`` اضافه نمی‌شود."

msgid "Added support for single-dash options."
msgstr "پشتیبانی از گزینه‌های تک‌خط‌تیره اضافه شد."

msgid "Added support for alternate prefix_chars_."
msgstr "پشتیبانی از prefix_chars_ جایگزین اضافه شد."

msgid "The parse_args() method"
msgstr "متد parse_args()"

msgid "Convert argument strings to objects and assign them as attributes of the namespace.  Return the populated namespace."
msgstr "رشته‌های آرگومان را به شیء تبدیل کنید و آن‌ها را به‌عنوان ویژگی‌های فضای نام اختصاص دهید. فضای نام پرشده را برگردانید."

msgid "Previous calls to :meth:`add_argument` determine exactly what objects are created and how they are assigned. See the documentation for :meth:`!add_argument` for details."
msgstr "فراخوانی‌های قبلی به :meth:`add_argument` دقیقاً تعیین می‌کنند که چه اشیایی ایجاد می‌شوند و چگونه اختصاص داده می‌شوند. برای جزئیات، مستندات :meth:`!add_argument` را ببینید."

msgid "args_ - List of strings to parse.  The default is taken from :data:`sys.argv`."
msgstr "args_ - فهرستی از رشته‌ها برای تجزیه. مقدار پیش‌فرض از :data:`sys.argv` گرفته می‌شود."

msgid "namespace_ - An object to take the attributes.  The default is a new empty :class:`Namespace` object."
msgstr "namespace_ - شیءای که ویژگی‌ها را دریافت می‌کند. پیش‌فرض یک شیء :class:`Namespace` جدید و خالی است."

msgid "Option value syntax"
msgstr "سینتکس مقدار گزینه"

msgid "The :meth:`~ArgumentParser.parse_args` method supports several ways of specifying the value of an option (if it takes one).  In the simplest case, the option and its value are passed as two separate arguments::"
msgstr "متد :meth:`~ArgumentParser.parse_args` از چندین روش برای تعیین مقدار یک گزینه (در صورتی که مقداری بپذیرد) پشتیبانی می‌کند. در ساده‌ترین حالت، گزینه و مقدار آن به‌عنوان دو آرگومان جداگانه ارسال می‌شوند::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-x')\n"
">>> parser.add_argument('--foo')\n"
">>> parser.parse_args(['-x', 'X'])\n"
"Namespace(foo=None, x='X')\n"
">>> parser.parse_args(['--foo', 'FOO'])\n"
"Namespace(foo='FOO', x=None)"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-x')\n"
">>> parser.add_argument('--foo')\n"
">>> parser.parse_args(['-x', 'X'])\n"
"Namespace(foo=None, x='X')\n"
">>> parser.parse_args(['--foo', 'FOO'])\n"
"Namespace(foo='FOO', x=None)"

msgid "For long options (options with names longer than a single character), the option and value can also be passed as a single command-line argument, using ``=`` to separate them::"
msgstr "برای گزینه‌های بلند (گزینه‌هایی با نام‌هایی طولانی‌تر از یک نویسه)، می‌توان گزینه و مقدار را به‌عنوان یک آرگومان خط فرمان واحد نیز ارسال کرد و برای جداسازی آن‌ها از ``=`` استفاده کرد::"

msgid ""
">>> parser.parse_args(['--foo=FOO'])\n"
"Namespace(foo='FOO', x=None)"
msgstr ""
">>> parser.parse_args(['--foo=FOO'])\n"
"Namespace(foo='FOO', x=None)"

msgid "For short options (options only one character long), the option and its value can be concatenated::"
msgstr "برای گزینه‌های کوتاه (گزینه‌هایی که فقط یک نویسه طول دارند)، می‌توان گزینه و مقدار آن را به‌هم چسباند::"

msgid ""
">>> parser.parse_args(['-xX'])\n"
"Namespace(foo=None, x='X')"
msgstr ""
">>> parser.parse_args(['-xX'])\n"
"Namespace(foo=None, x='X')"

msgid "Several short options can be joined together, using only a single ``-`` prefix, as long as only the last option (or none of them) requires a value::"
msgstr "می‌توان چند گزینه کوتاه را با استفاده از تنها یک پیشوند ``-`` با هم ترکیب کرد، مشروط بر اینکه فقط آخرین گزینه (یا هیچ‌کدام از آن‌ها) نیازمند مقدار باشد::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-x', action='store_true')\n"
">>> parser.add_argument('-y', action='store_true')\n"
">>> parser.add_argument('-z')\n"
">>> parser.parse_args(['-xyzZ'])\n"
"Namespace(x=True, y=True, z='Z')"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-x', action='store_true')\n"
">>> parser.add_argument('-y', action='store_true')\n"
">>> parser.add_argument('-z')\n"
">>> parser.parse_args(['-xyzZ'])\n"
"Namespace(x=True, y=True, z='Z')"

msgid "Invalid arguments"
msgstr "آرگومان‌های نامعتبر"

msgid "While parsing the command line, :meth:`~ArgumentParser.parse_args` checks for a variety of errors, including ambiguous options, invalid types, invalid options, wrong number of positional arguments, etc.  When it encounters such an error, it exits and prints the error along with a usage message::"
msgstr "هنگام تجزیه خط فرمان، :meth:`~ArgumentParser.parse_args` خطاهای مختلفی را بررسی می‌کند، از جمله گزینه‌های مبهم، انواع نامعتبر، گزینه‌های نامعتبر، تعداد نادرست آرگومان‌های جایگاهی و غیره. هنگامی که با چنین خطایی مواجه می‌شود، خارج می‌شود و خطا را به همراه پیام کاربرد چاپ می‌کند::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('--foo', type=int)\n"
">>> parser.add_argument('bar', nargs='?')\n"
"\n"
">>> # invalid type\n"
">>> parser.parse_args(['--foo', 'spam'])\n"
"usage: PROG [-h] [--foo FOO] [bar]\n"
"PROG: error: argument --foo: invalid int value: 'spam'\n"
"\n"
">>> # invalid option\n"
">>> parser.parse_args(['--bar'])\n"
"usage: PROG [-h] [--foo FOO] [bar]\n"
"PROG: error: unrecognized arguments: --bar\n"
"\n"
">>> # wrong number of arguments\n"
">>> parser.parse_args(['spam', 'badger'])\n"
"usage: PROG [-h] [--foo FOO] [bar]\n"
"PROG: error: unrecognized arguments: badger"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('--foo', type=int)\n"
">>> parser.add_argument('bar', nargs='?')\n"
"\n"
">>> # invalid type\n"
">>> parser.parse_args(['--foo', 'spam'])\n"
"usage: PROG [-h] [--foo FOO] [bar]\n"
"PROG: error: argument --foo: invalid int value: 'spam'\n"
"\n"
">>> # invalid option\n"
">>> parser.parse_args(['--bar'])\n"
"usage: PROG [-h] [--foo FOO] [bar]\n"
"PROG: error: unrecognized arguments: --bar\n"
"\n"
">>> # wrong number of arguments\n"
">>> parser.parse_args(['spam', 'badger'])\n"
"usage: PROG [-h] [--foo FOO] [bar]\n"
"PROG: error: unrecognized arguments: badger"

msgid "Arguments containing ``-``"
msgstr "آرگومان‌های شامل ``-``"

msgid "The :meth:`~ArgumentParser.parse_args` method attempts to give errors whenever the user has clearly made a mistake, but some situations are inherently ambiguous.  For example, the command-line argument ``-1`` could either be an attempt to specify an option or an attempt to provide a positional argument. The :meth:`~ArgumentParser.parse_args` method is cautious here: positional arguments may only begin with ``-`` if they look like negative numbers and there are no options in the parser that look like negative numbers::"
msgstr "متد :meth:`~ArgumentParser.parse_args` تلاش می‌کند هرگاه کاربر به‌وضوح اشتباهی مرتکب شده باشد، خطا گزارش کند، اما برخی موقعیت‌ها ذاتاً مبهم هستند. برای مثال، آرگومان خط فرمان ``-1`` می‌تواند تلاشی برای مشخص کردن یک گزینه یا تلاشی برای ارائه یک آرگومان جایگاهی باشد. متد :meth:`~ArgumentParser.parse_args` در اینجا محتاط است: آرگومان‌های جایگاهی تنها در صورتی می‌توانند با ``-`` شروع شوند که شبیه اعداد منفی باشند و هیچ گزینه‌ای در پارسر وجود نداشته باشد که شبیه اعداد منفی باشد::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-x')\n"
">>> parser.add_argument('foo', nargs='?')\n"
"\n"
">>> # no negative number options, so -1 is a positional argument\n"
">>> parser.parse_args(['-x', '-1'])\n"
"Namespace(foo=None, x='-1')\n"
"\n"
">>> # no negative number options, so -1 and -5 are positional arguments\n"
">>> parser.parse_args(['-x', '-1', '-5'])\n"
"Namespace(foo='-5', x='-1')\n"
"\n"
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-1', dest='one')\n"
">>> parser.add_argument('foo', nargs='?')\n"
"\n"
">>> # negative number options present, so -1 is an option\n"
">>> parser.parse_args(['-1', 'X'])\n"
"Namespace(foo=None, one='X')\n"
"\n"
">>> # negative number options present, so -2 is an option\n"
">>> parser.parse_args(['-2'])\n"
"usage: PROG [-h] [-1 ONE] [foo]\n"
"PROG: error: unrecognized arguments: -2\n"
"\n"
">>> # negative number options present, so both -1s are options\n"
">>> parser.parse_args(['-1', '-1'])\n"
"usage: PROG [-h] [-1 ONE] [foo]\n"
"PROG: error: argument -1: expected one argument"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-x')\n"
">>> parser.add_argument('foo', nargs='?')\n"
"\n"
">>> # no negative number options, so -1 is a positional argument\n"
">>> parser.parse_args(['-x', '-1'])\n"
"Namespace(foo=None, x='-1')\n"
"\n"
">>> # no negative number options, so -1 and -5 are positional arguments\n"
">>> parser.parse_args(['-x', '-1', '-5'])\n"
"Namespace(foo='-5', x='-1')\n"
"\n"
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-1', dest='one')\n"
">>> parser.add_argument('foo', nargs='?')\n"
"\n"
">>> # negative number options present, so -1 is an option\n"
">>> parser.parse_args(['-1', 'X'])\n"
"Namespace(foo=None, one='X')\n"
"\n"
">>> # negative number options present, so -2 is an option\n"
">>> parser.parse_args(['-2'])\n"
"usage: PROG [-h] [-1 ONE] [foo]\n"
"PROG: error: unrecognized arguments: -2\n"
"\n"
">>> # negative number options present, so both -1s are options\n"
">>> parser.parse_args(['-1', '-1'])\n"
"usage: PROG [-h] [-1 ONE] [foo]\n"
"PROG: error: argument -1: expected one argument"

msgid "If you have positional arguments that must begin with ``-`` and don't look like negative numbers, you can insert the pseudo-argument ``'--'`` which tells :meth:`~ArgumentParser.parse_args` that everything after that is a positional argument::"
msgstr "اگر آرگومان‌های جایگاهی دارید که باید با ``-`` شروع شوند و شبیه اعداد منفی نیستند، می‌توانید شبه‌آرگومان ``'--'`` را درج کنید که به :meth:`~ArgumentParser.parse_args` می‌گوید هرچه پس از آن می‌آید آرگومان جایگاهی است::"

msgid ""
">>> parser.parse_args(['--', '-f'])\n"
"Namespace(foo='-f', one=None)"
msgstr ""
">>> parser.parse_args(['--', '-f'])\n"
"Namespace(foo='-f', one=None)"

msgid "See also :ref:`the argparse howto on ambiguous arguments <specifying-ambiguous-arguments>` for more details."
msgstr "برای جزئیات بیشتر، :ref:`راهنمای argparse درباره آرگومان‌های مبهم <specifying-ambiguous-arguments>` را نیز ببینید."

msgid "Negative-number matching was expanded to include numbers in scientific notation (``-2.5e-6``), numbers containing underscores (``-1_234.5``), and complex numbers (``-1.2e-3j``)."
msgstr "جستجوی اعداد منفی برای شامل شدن اعداد در نمادگذاری علمی (``-2.5e-6``)، اعداد حاوی زیرخط (``-1_234.5``)، و اعداد مختلط (``-1.2e-3j``) گسترش یافت."

msgid "Argument abbreviations (prefix matching)"
msgstr "مخفف‌های آرگومان (تطبیق پیشوند)"

msgid "The :meth:`~ArgumentParser.parse_args` method :ref:`by default <allow_abbrev>` allows long options to be abbreviated to a prefix, if the abbreviation is unambiguous (the prefix matches a unique option)::"
msgstr "متد :meth:`~ArgumentParser.parse_args` :ref:`به‌طور پیش‌فرض <allow_abbrev>` اجازه می‌دهد گزینه‌های بلند به یک پیشوند اختصار یابند، اگر اختصار مبهم نباشد (پیشوند با یک گزینه‌ی یکتا مطابقت داشته باشد)::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-bacon')\n"
">>> parser.add_argument('-badger')\n"
">>> parser.parse_args('-bac MMM'.split())\n"
"Namespace(bacon='MMM', badger=None)\n"
">>> parser.parse_args('-bad WOOD'.split())\n"
"Namespace(bacon=None, badger='WOOD')\n"
">>> parser.parse_args('-ba BA'.split())\n"
"usage: PROG [-h] [-bacon BACON] [-badger BADGER]\n"
"PROG: error: ambiguous option: -ba could match -badger, -bacon"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-bacon')\n"
">>> parser.add_argument('-badger')\n"
">>> parser.parse_args('-bac MMM'.split())\n"
"Namespace(bacon='MMM', badger=None)\n"
">>> parser.parse_args('-bad WOOD'.split())\n"
"Namespace(bacon=None, badger='WOOD')\n"
">>> parser.parse_args('-ba BA'.split())\n"
"usage: PROG [-h] [-bacon BACON] [-badger BADGER]\n"
"PROG: error: ambiguous option: -ba could match -badger, -bacon"

msgid "An error is produced for arguments that could produce more than one options. This feature can be disabled by setting :ref:`allow_abbrev` to ``False``."
msgstr "برای آرگومان‌هایی که ممکن است بیش از یک گزینه تولید کنند، خطایی تولید می‌شود. این قابلیت را می‌توان با تنظیم :ref:`allow_abbrev <allow_abbrev>` روی ``False`` غیرفعال کرد."

msgid "Beyond ``sys.argv``"
msgstr "فراتر از ``sys.argv``"

msgid "Sometimes it may be useful to have an :class:`ArgumentParser` parse arguments other than those of :data:`sys.argv`.  This can be accomplished by passing a list of strings to :meth:`~ArgumentParser.parse_args`.  This is useful for testing at the interactive prompt::"
msgstr "گاهی ممکن است مفید باشد که یک :class:`ArgumentParser` آرگومان‌هایی غیر از آرگومان‌های :data:`sys.argv` را تجزیه کند. این کار را می‌توان با گذراندن فهرستی از رشته‌ها به :meth:`~ArgumentParser.parse_args` انجام داد. این برای آزمون در خط فرمان تعاملی مفید است::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument(\n"
"...     'integers', metavar='int', type=int, choices=range(10),\n"
"...     nargs='+', help='an integer in the range 0..9')\n"
">>> parser.add_argument(\n"
"...     '--sum', dest='accumulate', action='store_const', const=sum,\n"
"...     default=max, help='sum the integers (default: find the max)')\n"
">>> parser.parse_args(['1', '2', '3', '4'])\n"
"Namespace(accumulate=<built-in function max>, integers=[1, 2, 3, 4])\n"
">>> parser.parse_args(['1', '2', '3', '4', '--sum'])\n"
"Namespace(accumulate=<built-in function sum>, integers=[1, 2, 3, 4])"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument(\n"
"...     'integers', metavar='int', type=int, choices=range(10),\n"
"...     nargs='+', help='an integer in the range 0..9')\n"
">>> parser.add_argument(\n"
"...     '--sum', dest='accumulate', action='store_const', const=sum,\n"
"...     default=max, help='sum the integers (default: find the max)')\n"
">>> parser.parse_args(['1', '2', '3', '4'])\n"
"Namespace(accumulate=<built-in function max>, integers=[1, 2, 3, 4])\n"
">>> parser.parse_args(['1', '2', '3', '4', '--sum'])\n"
"Namespace(accumulate=<built-in function sum>, integers=[1, 2, 3, 4])"

msgid "The Namespace object"
msgstr "شیء فضای نام"

msgid "Simple class used by default by :meth:`~ArgumentParser.parse_args` to create an object holding attributes and return it."
msgstr "کلاس ساده‌ای که به‌طور پیش‌فرض توسط :meth:`~ArgumentParser.parse_args` برای ایجاد یک شیء حاوی ویژگی‌ها و بازگرداندن آن استفاده می‌شود."

msgid "This class is deliberately simple, just an :class:`object` subclass with a readable string representation. If you prefer to have dict-like view of the attributes, you can use the standard Python idiom, :func:`vars`::"
msgstr "این کلاس عمداً ساده است؛ فقط یک زیرکلاس از :class:`object` با بازنمایی رشته‌ای خوانا است. اگر ترجیح می‌دهید نمایی دیکشنری‌مانند از ویژگی‌ها داشته باشید، می‌توانید از الگوی استاندارد پایتون استفاده کنید: :func:`vars`::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo')\n"
">>> args = parser.parse_args(['--foo', 'BAR'])\n"
">>> vars(args)\n"
"{'foo': 'BAR'}"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo')\n"
">>> args = parser.parse_args(['--foo', 'BAR'])\n"
">>> vars(args)\n"
"{'foo': 'BAR'}"

msgid "It may also be useful to have an :class:`ArgumentParser` assign attributes to an already existing object, rather than a new :class:`Namespace` object.  This can be achieved by specifying the ``namespace=`` keyword argument::"
msgstr "همچنین ممکن است مفید باشد که یک :class:`ArgumentParser` ویژگی‌هایی را به یک شیء از پیش موجود اختصاص دهد، نه به یک شیء :class:`Namespace` جدید. این کار را می‌توان با تعیین آرگومان کلیدواژه‌ای ``namespace=`` انجام داد::"

msgid ""
">>> class C:\n"
"...     pass\n"
"...\n"
">>> c = C()\n"
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo')\n"
">>> parser.parse_args(args=['--foo', 'BAR'], namespace=c)\n"
">>> c.foo\n"
"'BAR'"
msgstr ""
">>> class C:\n"
"...     pass\n"
"...\n"
">>> c = C()\n"
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo')\n"
">>> parser.parse_args(args=['--foo', 'BAR'], namespace=c)\n"
">>> c.foo\n"
"'BAR'"

msgid "Other utilities"
msgstr "سایر ابزارها"

msgid "Subcommands"
msgstr "زیرفرمان‌ها"

msgid "Many programs split up their functionality into a number of subcommands, for example, the ``svn`` program can invoke subcommands like ``svn checkout``, ``svn update``, and ``svn commit``.  Splitting up functionality this way can be a particularly good idea when a program performs several different functions which require different kinds of command-line arguments. :class:`ArgumentParser` supports the creation of such subcommands with the :meth:`!add_subparsers` method.  The :meth:`!add_subparsers` method is normally called with no arguments and returns a special action object.  This object has a single method, :meth:`~_SubParsersAction.add_parser`, which takes a command name and any :class:`!ArgumentParser` constructor arguments, and returns an :class:`!ArgumentParser` object that can be modified as usual."
msgstr "بسیاری از برنامه‌ها قابلیت‌های خود را به تعدادی زیردستور تقسیم می‌کنند؛ برای مثال، برنامه‌ی ``svn`` می‌تواند زیردستورهایی مانند ``svn checkout``، ``svn update`` و ``svn commit`` را فراخوانی کند. تقسیم قابلیت‌ها به این روش می‌تواند ایده‌ای بسیار خوب باشد، به‌ویژه زمانی که یک برنامه چندین کارکرد مختلف انجام می‌دهد که به انواع مختلفی از آرگومان‌های خط فرمان نیاز دارند. :class:`ArgumentParser` از ایجاد چنین زیردستورهایی با متد :meth:`!add_subparsers` پشتیبانی می‌کند. متد :meth:`!add_subparsers` معمولاً بدون هیچ آرگومانی فراخوانی می‌شود و یک شیء اکشن ویژه برمی‌گرداند. این شیء تنها یک متد دارد، :meth:`~_SubParsersAction.add_parser`، که یک نام دستور و هرگونه آرگومان سازنده‌ی :class:`!ArgumentParser` را دریافت می‌کند و یک شیء :class:`!ArgumentParser` برمی‌گرداند که می‌توان آن را مانند حالت معمول اصلاح کرد."

msgid "Description of parameters:"
msgstr "توضیح پارامترها:"

msgid "*title* - title for the sub-parser group in help output; by default \"subcommands\" if description is provided, otherwise uses title for positional arguments"
msgstr "*title* - عنوان برای گروه زیرپارسر (sub-parser) در خروجی راهنما؛ به‌طور پیش‌فرض اگر توضیحات ارائه شده باشد، \"subcommands\" خواهد بود، در غیر این صورت، از عنوان آرگومان‌های جایگاهی استفاده می‌شود"

msgid "*description* - description for the sub-parser group in help output, by default ``None``"
msgstr "*description* - توضیح برای گروه زیرپارسرها در خروجی راهنما، به‌طور پیش‌فرض ``None``"

msgid "*prog* - usage information that will be displayed with subcommand help, by default the name of the program and any positional arguments before the subparser argument"
msgstr "*prog* - اطلاعات استفاده‌ای که همراه با راهنمای زیردستور نمایش داده می‌شود، به‌طور پیش‌فرض نام برنامه و هر آرگومان جایگاهی پیش از آرگومان زیرپارسر (subparser)"

msgid "*parser_class* - class which will be used to create sub-parser instances, by default the class of the current parser (e.g. :class:`ArgumentParser`)"
msgstr "*parser_class* - کلاسی که برای ایجاد نمونه‌های زیرپارسر استفاده خواهد شد، به‌طور پیش‌فرض کلاس پارسر فعلی (مثلاً :class:`ArgumentParser`)"

msgid "action_ - the basic type of action to be taken when this argument is encountered at the command line"
msgstr "action_ - نوع پایه‌ای اکشنی که باید هنگام مواجهه با این آرگومان در خط فرمان انجام شود"

msgid "dest_ - name of the attribute under which subcommand name will be stored; by default ``None`` and no value is stored"
msgstr "dest_ - نام ویژگی‌ای که نام زیردستور در آن ذخیره می‌شود؛ به‌طور پیش‌فرض ``None`` است و هیچ مقداری ذخیره نمی‌شود"

msgid "required_ - Whether or not a subcommand must be provided, by default ``False`` (added in 3.7)"
msgstr "required_ - اینکه آیا یک زیردستور باید ارائه شود یا خیر، به‌طور پیش‌فرض ``False`` (در 3.7 افزوده شده است)"

msgid "help_ - help for sub-parser group in help output, by default ``None``"
msgstr "help_ - راهنمای گروه زیرپارسرها در خروجی راهنما، به‌طور پیش‌فرض ``None``"

msgid "metavar_ - string presenting available subcommands in help; by default it is ``None`` and presents subcommands in form {cmd1, cmd2, ..}"
msgstr "metavar_ - رشته‌ای که زیردستورهای در دسترس را در راهنما نمایش می‌دهد؛ به‌طور پیش‌فرض ``None`` است و زیردستورها را در قالب {cmd1, cmd2, ..} نمایش می‌دهد"

msgid "Some example usage::"
msgstr "چند نمونه کاربرد::"

msgid ""
">>> # create the top-level parser\n"
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('--foo', action='store_true', help='foo help')\n"
">>> subparsers = parser.add_subparsers(help='subcommand help')\n"
">>>\n"
">>> # create the parser for the \"a\" command\n"
">>> parser_a = subparsers.add_parser('a', help='a help')\n"
">>> parser_a.add_argument('bar', type=int, help='bar help')\n"
">>>\n"
">>> # create the parser for the \"b\" command\n"
">>> parser_b = subparsers.add_parser('b', help='b help')\n"
">>> parser_b.add_argument('--baz', choices=('X', 'Y', 'Z'), help='baz help')\n"
">>>\n"
">>> # parse some argument lists\n"
">>> parser.parse_args(['a', '12'])\n"
"Namespace(bar=12, foo=False)\n"
">>> parser.parse_args(['--foo', 'b', '--baz', 'Z'])\n"
"Namespace(baz='Z', foo=True)"
msgstr ""
">>> # create the top-level parser\n"
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('--foo', action='store_true', help='foo help')\n"
">>> subparsers = parser.add_subparsers(help='subcommand help')\n"
">>>\n"
">>> # create the parser for the \"a\" command\n"
">>> parser_a = subparsers.add_parser('a', help='a help')\n"
">>> parser_a.add_argument('bar', type=int, help='bar help')\n"
">>>\n"
">>> # create the parser for the \"b\" command\n"
">>> parser_b = subparsers.add_parser('b', help='b help')\n"
">>> parser_b.add_argument('--baz', choices=('X', 'Y', 'Z'), help='baz help')\n"
">>>\n"
">>> # parse some argument lists\n"
">>> parser.parse_args(['a', '12'])\n"
"Namespace(bar=12, foo=False)\n"
">>> parser.parse_args(['--foo', 'b', '--baz', 'Z'])\n"
"Namespace(baz='Z', foo=True)"

msgid "Note that the object returned by :meth:`~ArgumentParser.parse_args` will only contain attributes for the main parser and the subparser that was selected by the command line (and not any other subparsers).  So in the example above, when the ``a`` command is specified, only the ``foo`` and ``bar`` attributes are present, and when the ``b`` command is specified, only the ``foo`` and ``baz`` attributes are present."
msgstr "توجه داشته باشید که شیء بازگردانده‌شده توسط :meth:`~ArgumentParser.parse_args` تنها شامل ویژگی‌های مربوط به پارسر اصلی و زیرپارسری خواهد بود که توسط خط فرمان انتخاب شده است (و شامل سایر زیرپارسرها نمی‌شود). بنابراین در مثال بالا، هنگامی که دستور ``a`` مشخص می‌شود، تنها ویژگی‌های ``foo`` و ``bar`` حضور دارند، و هنگامی که دستور ``b`` مشخص می‌شود، تنها ویژگی‌های ``foo`` و ``baz`` حضور دارند."

msgid "If a subparser defines an argument with the same ``dest`` as the parent parser, the two share a single namespace attribute, so the parent's value won't be retained. Users should give them  distinct ``dest`` values to keep both."
msgstr "اگر یک زیرپارسر آرگومانی با همان ``dest`` پارسر والد تعریف کند، این دو یک ویژگی فضای نام واحد را به اشتراک می‌گذارند، بنابراین مقدار پارسر والد حفظ نخواهد شد. کاربران باید برای آن‌ها مقادیر ``dest`` متمایزی تعیین کنند تا هر دو حفظ شوند."

msgid "Similarly, when a help message is requested from a subparser, only the help for that particular parser will be printed.  The help message will not include parent parser or sibling parser messages.  (A help message for each subparser command, however, can be given by supplying the ``help=`` argument to :meth:`~_SubParsersAction.add_parser` as above.)"
msgstr "به‌طور مشابه، هنگامی که یک پیام راهنما از یک زیرپارسر درخواست شود، فقط راهنمای همان پارسر خاص چاپ خواهد شد. پیام راهنما شامل پیام‌های پارسر والد یا پارسرهای هم‌سطح نخواهد شد. (با این حال، می‌توان با ارائه آرگومان ``help=`` به :meth:`~_SubParsersAction.add_parser` مانند بالا، یک پیام راهنما برای هر دستور زیرپارسر ارائه داد.)"

msgid ""
">>> parser.parse_args(['--help'])\n"
"usage: PROG [-h] [--foo] {a,b} ...\n"
"\n"
"positional arguments:\n"
"  {a,b}   subcommand help\n"
"    a     a help\n"
"    b     b help\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"  --foo   foo help\n"
"\n"
">>> parser.parse_args(['a', '--help'])\n"
"usage: PROG a [-h] bar\n"
"\n"
"positional arguments:\n"
"  bar     bar help\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"\n"
">>> parser.parse_args(['b', '--help'])\n"
"usage: PROG b [-h] [--baz {X,Y,Z}]\n"
"\n"
"options:\n"
"  -h, --help     show this help message and exit\n"
"  --baz {X,Y,Z}  baz help"
msgstr ""
">>> parser.parse_args(['--help'])\n"
"usage: PROG [-h] [--foo] {a,b} ...\n"
"\n"
"positional arguments:\n"
"  {a,b}   subcommand help\n"
"    a     a help\n"
"    b     b help\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"  --foo   foo help\n"
"\n"
">>> parser.parse_args(['a', '--help'])\n"
"usage: PROG a [-h] bar\n"
"\n"
"positional arguments:\n"
"  bar     bar help\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"\n"
">>> parser.parse_args(['b', '--help'])\n"
"usage: PROG b [-h] [--baz {X,Y,Z}]\n"
"\n"
"options:\n"
"  -h, --help     show this help message and exit\n"
"  --baz {X,Y,Z}  baz help"

msgid "The :meth:`~ArgumentParser.add_subparsers` method also supports ``title`` and ``description`` keyword arguments.  When either is present, the subparser's commands will appear in their own group in the help output.  For example::"
msgstr "متد :meth:`~ArgumentParser.add_subparsers` همچنین از آرگومان‌های کلیدواژه‌ای ``title`` و ``description`` پشتیبانی می‌کند. هنگامی که هر یک از آن‌ها حضور داشته باشد، دستورات زیرپارسر در گروه مختص به خود در خروجی راهنما ظاهر خواهند شد. برای مثال::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> subparsers = parser.add_subparsers(title='subcommands',\n"
"...                                    description='valid subcommands',\n"
"...                                    help='additional help')\n"
">>> subparsers.add_parser('foo')\n"
">>> subparsers.add_parser('bar')\n"
">>> parser.parse_args(['-h'])\n"
"usage:  [-h] {foo,bar} ...\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"\n"
"subcommands:\n"
"  valid subcommands\n"
"\n"
"  {foo,bar}   additional help"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> subparsers = parser.add_subparsers(title='subcommands',\n"
"...                                    description='valid subcommands',\n"
"...                                    help='additional help')\n"
">>> subparsers.add_parser('foo')\n"
">>> subparsers.add_parser('bar')\n"
">>> parser.parse_args(['-h'])\n"
"usage:  [-h] {foo,bar} ...\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"\n"
"subcommands:\n"
"  valid subcommands\n"
"\n"
"  {foo,bar}   additional help"

msgid "One particularly effective way of handling subcommands is to combine the use of the :meth:`~ArgumentParser.add_subparsers` method with calls to :meth:`~ArgumentParser.set_defaults` so that each subparser knows which Python function it should execute.  For example::"
msgstr "یک روش به خصوص مؤثر برای مدیریت زیردستورات، ترکیب استفاده از متد :meth:`~ArgumentParser.add_subparsers` با فراخوانی‌های :meth:`~ArgumentParser.set_defaults` است تا هر زیرپارسر بداند که کدام تابع پایتون را باید اجرا کند. برای مثال::"

msgid ""
">>> # subcommand functions\n"
">>> def foo(args):\n"
"...     print(args.x * args.y)\n"
"...\n"
">>> def bar(args):\n"
"...     print('((%s))' % args.z)\n"
"...\n"
">>> # create the top-level parser\n"
">>> parser = argparse.ArgumentParser()\n"
">>> subparsers = parser.add_subparsers(required=True)\n"
">>>\n"
">>> # create the parser for the \"foo\" command\n"
">>> parser_foo = subparsers.add_parser('foo')\n"
">>> parser_foo.add_argument('-x', type=int, default=1)\n"
">>> parser_foo.add_argument('y', type=float)\n"
">>> parser_foo.set_defaults(func=foo)\n"
">>>\n"
">>> # create the parser for the \"bar\" command\n"
">>> parser_bar = subparsers.add_parser('bar')\n"
">>> parser_bar.add_argument('z')\n"
">>> parser_bar.set_defaults(func=bar)\n"
">>>\n"
">>> # parse the args and call whatever function was selected\n"
">>> args = parser.parse_args('foo 1 -x 2'.split())\n"
">>> args.func(args)\n"
"2.0\n"
">>>\n"
">>> # parse the args and call whatever function was selected\n"
">>> args = parser.parse_args('bar XYZYX'.split())\n"
">>> args.func(args)\n"
"((XYZYX))"
msgstr ""
">>> # subcommand functions\n"
">>> def foo(args):\n"
"...     print(args.x * args.y)\n"
"...\n"
">>> def bar(args):\n"
"...     print('((%s))' % args.z)\n"
"...\n"
">>> # create the top-level parser\n"
">>> parser = argparse.ArgumentParser()\n"
">>> subparsers = parser.add_subparsers(required=True)\n"
">>>\n"
">>> # create the parser for the \"foo\" command\n"
">>> parser_foo = subparsers.add_parser('foo')\n"
">>> parser_foo.add_argument('-x', type=int, default=1)\n"
">>> parser_foo.add_argument('y', type=float)\n"
">>> parser_foo.set_defaults(func=foo)\n"
">>>\n"
">>> # create the parser for the \"bar\" command\n"
">>> parser_bar = subparsers.add_parser('bar')\n"
">>> parser_bar.add_argument('z')\n"
">>> parser_bar.set_defaults(func=bar)\n"
">>>\n"
">>> # parse the args and call whatever function was selected\n"
">>> args = parser.parse_args('foo 1 -x 2'.split())\n"
">>> args.func(args)\n"
"2.0\n"
">>>\n"
">>> # parse the args and call whatever function was selected\n"
">>> args = parser.parse_args('bar XYZYX'.split())\n"
">>> args.func(args)\n"
"((XYZYX))"

msgid "This way, you can let :meth:`~ArgumentParser.parse_args` do the job of calling the appropriate function after argument parsing is complete.  Associating functions with actions like this is typically the easiest way to handle the different actions for each of your subparsers.  However, if it is necessary to check the name of the subparser that was invoked, the ``dest`` keyword argument to the :meth:`~ArgumentParser.add_subparsers` call will work::"
msgstr "به این ترتیب، می‌توانید به :meth:`~ArgumentParser.parse_args` اجازه دهید کار فراخوانی تابع مناسب را پس از اتمام تجزیه آرگومان انجام دهد. مرتبط کردن توابع با کنش‌ها به این شکل، معمولاً آسان‌ترین راه برای مدیریت کنش‌های مختلف برای هر یک از زیرپارسرهای شما است. با این حال، اگر بررسی نام زیرپارسری که فراخوانی شده است ضروری باشد، آرگومان کلیدواژه‌ای ``dest`` در فراخوانی :meth:`~ArgumentParser.add_subparsers` کارساز خواهد بود::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> subparsers = parser.add_subparsers(dest='subparser_name')\n"
">>> subparser1 = subparsers.add_parser('1')\n"
">>> subparser1.add_argument('-x')\n"
">>> subparser2 = subparsers.add_parser('2')\n"
">>> subparser2.add_argument('y')\n"
">>> parser.parse_args(['2', 'frobble'])\n"
"Namespace(subparser_name='2', y='frobble')"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> subparsers = parser.add_subparsers(dest='subparser_name')\n"
">>> subparser1 = subparsers.add_parser('1')\n"
">>> subparser1.add_argument('-x')\n"
">>> subparser2 = subparsers.add_parser('2')\n"
">>> subparser2.add_argument('y')\n"
">>> parser.parse_args(['2', 'frobble'])\n"
"Namespace(subparser_name='2', y='frobble')"

msgid "New *required* keyword-only parameter."
msgstr "پارامتر جدید *الزامی* فقط کلیدواژه‌ای."

msgid "Subparser's *prog* is no longer affected by a custom usage message in the main parser."
msgstr "*prog* زیرپارسر دیگر تحت تأثیر پیام کاربرد سفارشی در پارسر اصلی قرار نمی‌گیرد."

msgid "Create and return a new :class:`ArgumentParser` object for the subcommand *name*."
msgstr "یک شیء جدید :class:`ArgumentParser` برای *name* (نام) زیردستور ایجاد کرده و برمی‌گرداند."

msgid "The *name* argument is the name of the sub-command."
msgstr "آرگومان *name* نام زیردستور است."

msgid "The *help* argument provides a short description for this sub-command."
msgstr "آرگومان *help* توضیح کوتاهی برای این زیردستور فراهم می‌کند."

msgid "The *aliases* argument allows providing alternative names for this sub-command. For example::"
msgstr "آرگومان *aliases* امکان ارائه‌ی نام‌های جایگزین را برای این زیردستور فراهم می‌کند. برای مثال::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> subparsers = parser.add_subparsers()\n"
">>> checkout = subparsers.add_parser('checkout', aliases=['co'])\n"
">>> checkout.add_argument('foo')\n"
">>> parser.parse_args(['co', 'bar'])\n"
"Namespace(foo='bar')"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> subparsers = parser.add_subparsers()\n"
">>> checkout = subparsers.add_parser('checkout', aliases=['co'])\n"
">>> checkout.add_argument('foo')\n"
">>> parser.parse_args(['co', 'bar'])\n"
"Namespace(foo='bar')"

msgid "The *deprecated* argument, if ``True``, marks the sub-command as deprecated and will issue a warning when used. For example::"
msgstr "آرگومان *deprecated*، اگر روی ``True`` تنظیم شود، زیردستور را به عنوان منسوخ علامت‌گذاری می‌کند و هنگام استفاده، اخطاری صادر خواهد کرد. برای مثال::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='chicken.py')\n"
">>> subparsers = parser.add_subparsers()\n"
">>> fly = subparsers.add_parser('fly', deprecated=True)\n"
">>> args = parser.parse_args(['fly'])\n"
"chicken.py: warning: command 'fly' is deprecated\n"
"Namespace()"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='chicken.py')\n"
">>> subparsers = parser.add_subparsers()\n"
">>> fly = subparsers.add_parser('fly', deprecated=True)\n"
">>> args = parser.parse_args(['fly'])\n"
"chicken.py: warning: command 'fly' is deprecated\n"
"Namespace()"

msgid "All other keyword arguments are passed directly to the :class:`!ArgumentParser` constructor."
msgstr "تمام آرگومان‌های کلیدواژه‌ای دیگر مستقیماً به سازنده‌ی :class:`!ArgumentParser` منتقل می‌شوند."

msgid "Added the *deprecated* parameter."
msgstr "پارامتر *deprecated* اضافه شد."

msgid "FileType objects"
msgstr "اشیای FileType"

msgid "The :class:`FileType` factory creates objects that can be passed to the type argument of :meth:`ArgumentParser.add_argument`.  Arguments that have :class:`FileType` objects as their type will open command-line arguments as files with the requested modes, buffer sizes, encodings and error handling (see the :func:`open` function for more details)::"
msgstr "کارخانه‌ی :class:`FileType` اشیایی را ایجاد می‌کند که می‌توان آن‌ها را به آرگومان type در :meth:`ArgumentParser.add_argument` ارسال کرد. آرگومان‌هایی که اشیای :class:`FileType` را به‌عنوان نوع خود دارند، آرگومان‌های خط فرمان را به‌صورت پرونده‌هایی با حالت‌ها، اندازه‌های بافر، کدگذاری‌ها و مدیریت خطای درخواستی باز می‌کنند (برای جزئیات بیشتر، تابع :func:`open` را ببینید)::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--raw', type=argparse.FileType('wb', 0))\n"
">>> parser.add_argument('out', type=argparse.FileType('w', encoding='UTF-8'))\n"
">>> parser.parse_args(['--raw', 'raw.dat', 'file.txt'])\n"
"Namespace(out=<_io.TextIOWrapper name='file.txt' mode='w' encoding='UTF-8'>, raw=<_io.FileIO name='raw.dat' mode='wb'>)"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--raw', type=argparse.FileType('wb', 0))\n"
">>> parser.add_argument('out', type=argparse.FileType('w', encoding='UTF-8'))\n"
">>> parser.parse_args(['--raw', 'raw.dat', 'file.txt'])\n"
"Namespace(out=<_io.TextIOWrapper name='file.txt' mode='w' encoding='UTF-8'>, raw=<_io.FileIO name='raw.dat' mode='wb'>)"

msgid "FileType objects understand the pseudo-argument ``'-'`` and automatically convert this into :data:`sys.stdin` for readable :class:`FileType` objects and :data:`sys.stdout` for writable :class:`FileType` objects::"
msgstr "اشیاء FileType شبه‌آرگومان ``'-'`` را می‌شناسند و به‌طور خودکار آن را برای اشیاء :class:`FileType` قابل خواندن به :data:`sys.stdin` و برای اشیاء :class:`FileType` قابل نوشتن به :data:`sys.stdout` تبدیل می‌کنند::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('infile', type=argparse.FileType('r'))\n"
">>> parser.parse_args(['-'])\n"
"Namespace(infile=<_io.TextIOWrapper name='<stdin>' encoding='UTF-8'>)"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('infile', type=argparse.FileType('r'))\n"
">>> parser.parse_args(['-'])\n"
"Namespace(infile=<_io.TextIOWrapper name='<stdin>' encoding='UTF-8'>)"

msgid "If one argument uses *FileType* and then a subsequent argument fails, an error is reported but the file is not automatically closed. This can also clobber the output files. In this case, it would be better to wait until after the parser has run and then use the :keyword:`with`-statement to manage the files."
msgstr "اگر یکی از آرگومان‌ها از *FileType* استفاده کند و سپس آرگومان بعدی با شکست مواجه شود، خطایی گزارش می‌شود اما پرونده به‌طور خودکار بسته نمی‌شود. این موضوع همچنین می‌تواند پرونده‌های خروجی را بازنویسی کند. در این حالت، بهتر است تا پایان اجرای پارسر صبر کنید و سپس از دستور :keyword:`with` برای مدیریت پرونده‌ها استفاده کنید."

msgid "Added the *encoding* and *errors* parameters."
msgstr "پارامترهای *encoding* و *errors* افزوده شدند."

msgid "Argument groups"
msgstr "گروه‌های آرگومان"

msgid "By default, :class:`ArgumentParser` groups command-line arguments into \"positional arguments\" and \"options\" when displaying help messages. When there is a better conceptual grouping of arguments than this default one, appropriate groups can be created using the :meth:`!add_argument_group` method::"
msgstr "به‌طور پیش‌فرض، :class:`ArgumentParser` آرگومان‌های خط فرمان را هنگام نمایش پیام‌های راهنمایی به «آرگومان‌های جایگاهی» و «گزینه‌ها» گروه‌بندی می‌کند. هرگاه گروه‌بندی مفهومی بهتری نسبت به این حالت پیش‌فرض برای آرگومان‌ها وجود داشته باشد، می‌توان گروه‌های مناسب را با استفاده از متد :meth:`!add_argument_group` ایجاد کرد::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)\n"
">>> group = parser.add_argument_group('group')\n"
">>> group.add_argument('--foo', help='foo help')\n"
">>> group.add_argument('bar', help='bar help')\n"
">>> parser.print_help()\n"
"usage: PROG [--foo FOO] bar\n"
"\n"
"group:\n"
"  bar    bar help\n"
"  --foo FOO  foo help"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)\n"
">>> group = parser.add_argument_group('group')\n"
">>> group.add_argument('--foo', help='foo help')\n"
">>> group.add_argument('bar', help='bar help')\n"
">>> parser.print_help()\n"
"usage: PROG [--foo FOO] bar\n"
"\n"
"group:\n"
"  bar    bar help\n"
"  --foo FOO  foo help"

msgid "The :meth:`add_argument_group` method returns an argument group object which has an :meth:`~ArgumentParser.add_argument` method just like a regular :class:`ArgumentParser`.  When an argument is added to the group, the parser treats it just like a normal argument, but displays the argument in a separate group for help messages.  The :meth:`!add_argument_group` method accepts *title* and *description* arguments which can be used to customize this display::"
msgstr "متد :meth:`add_argument_group` یک شیء گروه آرگومان برمی‌گرداند که همانند یک :class:`ArgumentParser` معمولی، متد :meth:`~ArgumentParser.add_argument` را دارد. هنگامی که آرگومانی به گروه اضافه می‌شود، پارسر با آن همانند یک آرگومان عادی رفتار می‌کند، اما آن را در پیام‌های راهنمایی در گروهی جداگانه نمایش می‌دهد. متد :meth:`!add_argument_group` آرگومان‌های *title* و *description* را می‌پذیرد که می‌توان از آن‌ها برای سفارشی‌سازی این نمایش استفاده کرد::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)\n"
">>> group1 = parser.add_argument_group('group1', 'group1 description')\n"
">>> group1.add_argument('foo', help='foo help')\n"
">>> group2 = parser.add_argument_group('group2', 'group2 description')\n"
">>> group2.add_argument('--bar', help='bar help')\n"
">>> parser.print_help()\n"
"usage: PROG [--bar BAR] foo\n"
"\n"
"group1:\n"
"  group1 description\n"
"\n"
"  foo    foo help\n"
"\n"
"group2:\n"
"  group2 description\n"
"\n"
"  --bar BAR  bar help"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)\n"
">>> group1 = parser.add_argument_group('group1', 'group1 description')\n"
">>> group1.add_argument('foo', help='foo help')\n"
">>> group2 = parser.add_argument_group('group2', 'group2 description')\n"
">>> group2.add_argument('--bar', help='bar help')\n"
">>> parser.print_help()\n"
"usage: PROG [--bar BAR] foo\n"
"\n"
"group1:\n"
"  group1 description\n"
"\n"
"  foo    foo help\n"
"\n"
"group2:\n"
"  group2 description\n"
"\n"
"  --bar BAR  bar help"

msgid "The optional, keyword-only parameters argument_default_ and conflict_handler_ allow for finer-grained control of the behavior of the argument group. These parameters have the same meaning as in the :class:`ArgumentParser` constructor, but apply specifically to the argument group rather than the entire parser."
msgstr "پارامترهای اختیاری و فقط کلیدواژه‌ای argument_default_ و conflict_handler_ امکان کنترل دقیق‌تر رفتار گروه آرگومان را فراهم می‌کنند. این پارامترها همان معنایی را دارند که در سازنده‌ی :class:`ArgumentParser` دارند، اما به‌طور خاص بر گروه آرگومان اعمال می‌شوند، نه بر کل پارسر."

msgid "Note that any arguments not in your user-defined groups will end up back in the usual \"positional arguments\" and \"optional arguments\" sections."
msgstr "توجه داشته باشید که هر آرگومانی که در گروه‌های تعریف‌شده توسط شما نباشد، در نهایت به بخش‌های معمول «آرگومان‌های جایگاهی» و «آرگومان‌های اختیاری» بازمی‌گردد."

msgid "Within each argument group, arguments are displayed in help output in the order in which they are added."
msgstr "در هر گروه آرگومان، آرگومان‌ها در خروجی راهنما به همان ترتیبی که افزوده شده‌اند نمایش داده می‌شوند."

msgid "Calling :meth:`add_argument_group` on an argument group now raises an exception. This nesting was never supported, often failed to work correctly, and was unintentionally exposed through inheritance."
msgstr "فراخوانی :meth:`add_argument_group` بر روی یک گروه آرگومان اکنون استثنا پرتاب می‌کند. این تودرتوسازی هرگز پشتیبانی نمی‌شد، اغلب به‌درستی کار نمی‌کرد و به‌طور غیرعمد از طریق ارث‌بری در دسترس قرار گرفته بود."

msgid "Passing prefix_chars_ to :meth:`add_argument_group` is now deprecated."
msgstr "ارسال prefix_chars_ به :meth:`add_argument_group` اکنون منسوخ شده است."

msgid "Mutual exclusion"
msgstr "انحصار متقابل"

msgid "Create a mutually exclusive group. :mod:`!argparse` will make sure that only one of the arguments in the mutually exclusive group was present on the command line::"
msgstr "یک گروه با انحصار متقابل ایجاد کنید. :mod:`!argparse` تضمین می‌کند که تنها یکی از آرگومان‌های گروه با انحصار متقابل در خط فرمان وجود داشته باشد::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> group = parser.add_mutually_exclusive_group()\n"
">>> group.add_argument('--foo', action='store_true')\n"
">>> group.add_argument('--bar', action='store_false')\n"
">>> parser.parse_args(['--foo'])\n"
"Namespace(bar=True, foo=True)\n"
">>> parser.parse_args(['--bar'])\n"
"Namespace(bar=False, foo=False)\n"
">>> parser.parse_args(['--foo', '--bar'])\n"
"usage: PROG [-h] [--foo | --bar]\n"
"PROG: error: argument --bar: not allowed with argument --foo"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> group = parser.add_mutually_exclusive_group()\n"
">>> group.add_argument('--foo', action='store_true')\n"
">>> group.add_argument('--bar', action='store_false')\n"
">>> parser.parse_args(['--foo'])\n"
"Namespace(bar=True, foo=True)\n"
">>> parser.parse_args(['--bar'])\n"
"Namespace(bar=False, foo=False)\n"
">>> parser.parse_args(['--foo', '--bar'])\n"
"usage: PROG [-h] [--foo | --bar]\n"
"PROG: error: argument --bar: not allowed with argument --foo"

msgid "The :meth:`add_mutually_exclusive_group` method also accepts a *required* argument, to indicate that at least one of the mutually exclusive arguments is required::"
msgstr "متد :meth:`add_mutually_exclusive_group` همچنین یک آرگومان *required* را می‌پذیرد، تا نشان دهد که حداقل یکی از آرگومان‌های مانع‌الجمع الزامی است::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> group = parser.add_mutually_exclusive_group(required=True)\n"
">>> group.add_argument('--foo', action='store_true')\n"
">>> group.add_argument('--bar', action='store_false')\n"
">>> parser.parse_args([])\n"
"usage: PROG [-h] (--foo | --bar)\n"
"PROG: error: one of the arguments --foo --bar is required"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> group = parser.add_mutually_exclusive_group(required=True)\n"
">>> group.add_argument('--foo', action='store_true')\n"
">>> group.add_argument('--bar', action='store_false')\n"
">>> parser.parse_args([])\n"
"usage: PROG [-h] (--foo | --bar)\n"
"PROG: error: one of the arguments --foo --bar is required"

msgid "Note that currently mutually exclusive argument groups do not support the *title* and *description* arguments of :meth:`~ArgumentParser.add_argument_group`. However, a mutually exclusive group can be added to an argument group that has a title and description. For example::"
msgstr "توجه کنید که در حال حاضر گروه‌های آرگومان انحصاریِ متقابل از آرگومان‌های *title* و *description* متد :meth:`~ArgumentParser.add_argument_group` پشتیبانی نمی‌کنند. بااین‌حال، یک گروه انحصاریِ متقابل را می‌توان به یک گروه آرگومان که دارای عنوان و توضیحات است اضافه کرد. برای مثال::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> group = parser.add_argument_group('Group title', 'Group description')\n"
">>> exclusive_group = group.add_mutually_exclusive_group(required=True)\n"
">>> exclusive_group.add_argument('--foo', help='foo help')\n"
">>> exclusive_group.add_argument('--bar', help='bar help')\n"
">>> parser.print_help()\n"
"usage: PROG [-h] (--foo FOO | --bar BAR)\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"\n"
"Group title:\n"
"  Group description\n"
"\n"
"  --foo FOO   foo help\n"
"  --bar BAR   bar help"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> group = parser.add_argument_group('Group title', 'Group description')\n"
">>> exclusive_group = group.add_mutually_exclusive_group(required=True)\n"
">>> exclusive_group.add_argument('--foo', help='foo help')\n"
">>> exclusive_group.add_argument('--bar', help='bar help')\n"
">>> parser.print_help()\n"
"usage: PROG [-h] (--foo FOO | --bar BAR)\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"\n"
"Group title:\n"
"  Group description\n"
"\n"
"  --foo FOO   foo help\n"
"  --bar BAR   bar help"

msgid "Calling :meth:`add_argument_group` or :meth:`add_mutually_exclusive_group` on a mutually exclusive group now raises an exception. This nesting was never supported, often failed to work correctly, and was unintentionally exposed through inheritance."
msgstr "فراخوانی :meth:`add_argument_group` یا :meth:`add_mutually_exclusive_group` روی یک گروه متقابلاً انحصاری اکنون استثنایی پرتاب می‌کند. این تودرتوسازی هرگز پشتیبانی نمی‌شد، اغلب به‌درستی کار نمی‌کرد و به‌طور غیرعمد از طریق ارث‌بری در دسترس قرار گرفته بود."

msgid "Parser defaults"
msgstr "پیش‌فرض‌های پارسر"

msgid "Most of the time, the attributes of the object returned by :meth:`parse_args` will be fully determined by inspecting the command-line arguments and the argument actions.  :meth:`set_defaults` allows some additional attributes that are determined without any inspection of the command line to be added::"
msgstr "بیشتر اوقات، ویژگی‌های شیء برگردانده‌شده توسط :meth:`parse_args` به‌طور کامل با بررسی آرگومان‌های خط فرمان و کنش‌های آرگومان تعیین می‌شوند.  :meth:`set_defaults` اجازه می‌دهد برخی ویژگی‌های اضافی که بدون هیچ‌گونه بررسی خط فرمان تعیین می‌شوند، اضافه شوند::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('foo', type=int)\n"
">>> parser.set_defaults(bar=42, baz='badger')\n"
">>> parser.parse_args(['736'])\n"
"Namespace(bar=42, baz='badger', foo=736)"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('foo', type=int)\n"
">>> parser.set_defaults(bar=42, baz='badger')\n"
">>> parser.parse_args(['736'])\n"
"Namespace(bar=42, baz='badger', foo=736)"

msgid "Note that defaults can be set at both the parser level using :meth:`set_defaults` and at the argument level using :meth:`add_argument`. If both are called for the same argument, the last default set for an argument is used::"
msgstr "توجه داشته باشید که پیش‌فرض‌ها را می‌توان هم در سطح پارسر با استفاده از :meth:`set_defaults` و هم در سطح آرگومان با استفاده از :meth:`add_argument` تنظیم کرد. اگر هر دو برای یک آرگومان فراخوانی شوند، آخرین پیش‌فرض تنظیم‌شده برای آن آرگومان استفاده می‌شود::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', default='bar')\n"
">>> parser.set_defaults(foo='spam')\n"
">>> parser.parse_args([])\n"
"Namespace(foo='spam')"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', default='bar')\n"
">>> parser.set_defaults(foo='spam')\n"
">>> parser.parse_args([])\n"
"Namespace(foo='spam')"

msgid "Parser-level defaults can be particularly useful when working with multiple parsers.  See the :meth:`~ArgumentParser.add_subparsers` method for an example of this type."
msgstr "پیش‌فرض‌های سطح پارسر می‌توانند به‌ویژه هنگام کار با چندین پارسر مفید باشند. برای دیدن نمونه‌ای از این نوع، به متد :meth:`~ArgumentParser.add_subparsers` مراجعه کنید."

msgid "Get the default value for a namespace attribute, as set by either :meth:`~ArgumentParser.add_argument` or by :meth:`~ArgumentParser.set_defaults`::"
msgstr "دریافت مقدار پیش‌فرض برای یک ویژگی فضای نام، که توسط :meth:`~ArgumentParser.add_argument` یا :meth:`~ArgumentParser.set_defaults` تنظیم شده است::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', default='badger')\n"
">>> parser.get_default('foo')\n"
"'badger'"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', default='badger')\n"
">>> parser.get_default('foo')\n"
"'badger'"

msgid "Printing help"
msgstr "چاپ راهنما"

msgid "In most typical applications, :meth:`~ArgumentParser.parse_args` will take care of formatting and printing any usage or error messages.  However, several formatting methods are available:"
msgstr "در بیشتر برنامه‌های معمول، :meth:`~ArgumentParser.parse_args` قالب‌بندی و چاپ هرگونه پیام کاربرد یا خطا را بر عهده می‌گیرد. با این حال، چندین متد قالب‌بندی در دسترس است:"

msgid "Print a brief description of how the :class:`ArgumentParser` should be invoked on the command line.  If *file* is ``None``, :data:`sys.stdout` is assumed."
msgstr "توضیح کوتاهی درباره نحوه فراخوانی :class:`ArgumentParser` در خط فرمان چاپ می‌کند. اگر *file* برابر ``None`` باشد، :data:`sys.stdout` در نظر گرفته می‌شود."

msgid "Print a help message, including the program usage and information about the arguments registered with the :class:`ArgumentParser`.  If *file* is ``None``, :data:`sys.stdout` is assumed."
msgstr "یک پیام راهنما چاپ می‌کند، شامل نحوه استفاده از برنامه و اطلاعات درباره آرگومان‌های ثبت‌شده در :class:`ArgumentParser`. اگر *file* برابر ``None`` باشد، :data:`sys.stdout` در نظر گرفته می‌شود."

msgid "There are also variants of these methods that simply return a string instead of printing it:"
msgstr "همچنین انواعی از این متدها وجود دارند که به‌جای چاپ کردن، صرفاً یک رشته را برمی‌گردانند:"

msgid "Return a string containing a brief description of how the :class:`ArgumentParser` should be invoked on the command line."
msgstr "رشته‌ای حاوی توضیح مختصری درباره نحوه فراخوانی :class:`ArgumentParser` در خط فرمان برمی‌گرداند."

msgid "Return a string containing a help message, including the program usage and information about the arguments registered with the :class:`ArgumentParser`."
msgstr "رشته‌ای حاوی پیام راهنما، شامل نحوه استفاده از برنامه و اطلاعاتی درباره آرگومان‌های ثبت‌شده در :class:`ArgumentParser` برمی‌گرداند."

msgid "Partial parsing"
msgstr "تجزیه جزئی"

msgid "Sometimes a script only needs to handle a specific set of command-line arguments, leaving any unrecognized arguments for another script or program. In these cases, the :meth:`~ArgumentParser.parse_known_args` method can be useful."
msgstr "گاهی اوقات یک اسکریپت تنها نیاز دارد مجموعه‌ای مشخص از آرگومان‌های خط فرمان را مدیریت کند و هر آرگومان ناشناخته‌ای را برای اسکریپت یا برنامه دیگری باقی بگذارد. در این موارد، متد :meth:`~ArgumentParser.parse_known_args` می‌تواند مفید باشد."

msgid "This method works similarly to :meth:`~ArgumentParser.parse_args`, but it does not raise an error for extra, unrecognized arguments. Instead, it parses the known arguments and returns a two item tuple that contains the populated namespace and the list of any unrecognized arguments."
msgstr "این متد مشابه :meth:`~ArgumentParser.parse_args` عمل می‌کند، اما برای آرگومان‌های اضافی و ناشناخته خطایی پرتاب نمی‌کند. در عوض، آرگومان‌های شناخته‌شده را تجزیه می‌کند و یک تاپل دو آیتمی برمی‌گرداند که شامل فضای نام مقداردهی‌شده و فهرستی از آرگومان‌های ناشناخته است."

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action='store_true')\n"
">>> parser.add_argument('bar')\n"
">>> parser.parse_known_args(['--foo', '--badger', 'BAR', 'spam'])\n"
"(Namespace(bar='BAR', foo=True), ['--badger', 'spam'])"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action='store_true')\n"
">>> parser.add_argument('bar')\n"
">>> parser.parse_known_args(['--foo', '--badger', 'BAR', 'spam'])\n"
"(Namespace(bar='BAR', foo=True), ['--badger', 'spam'])"

msgid ":ref:`Prefix matching <prefix-matching>` rules apply to :meth:`~ArgumentParser.parse_known_args`. The parser may consume an option even if it's just a prefix of one of its known options, instead of leaving it in the remaining arguments list."
msgstr "قواعد :ref:`تطبیق پیشوندی <prefix-matching>` بر :meth:`~ArgumentParser.parse_known_args` اعمال می‌شوند. پارسر ممکن است گزینه‌ای را، حتی اگر فقط پیشوندی از یکی از گزینه‌های شناخته‌شده‌اش باشد، به‌جای باقی گذاشتن آن در فهرست آرگومان‌های باقی‌مانده، مصرف کند."

msgid "Customizing file parsing"
msgstr "سفارشی‌سازی تجزیه پرونده"

msgid "Arguments that are read from a file (see the *fromfile_prefix_chars* keyword argument to the :class:`ArgumentParser` constructor) are read one argument per line. :meth:`convert_arg_line_to_args` can be overridden for fancier reading."
msgstr "آرگومان‌هایی که از یک پرونده خوانده می‌شوند (آرگومان کلیدواژه‌ای *fromfile_prefix_chars* در سازنده‌ی :class:`ArgumentParser` را ببینید)، به‌صورت یک آرگومان در هر خط خوانده می‌شوند. می‌توان :meth:`convert_arg_line_to_args` را برای خواندن پیشرفته‌تر بازنویسی کرد."

msgid "This method takes a single argument *arg_line* which is a string read from the argument file.  It returns a list of arguments parsed from this string. The method is called once per line read from the argument file, in order."
msgstr "این متد یک آرگومان واحد *arg_line* می‌گیرد که رشته‌ای خوانده‌شده از پرونده آرگومان است. این متد فهرستی از آرگومان‌های تجزیه‌شده از این رشته را برمی‌گرداند. این متد به ترتیب، یک بار به ازای هر خط خوانده‌شده از پرونده آرگومان فراخوانی می‌شود."

msgid "A useful override of this method is one that treats each space-separated word as an argument.  The following example demonstrates how to do this::"
msgstr "یک بازنویسی مفید از این متد، بازنویسی‌ای است که هر کلمه‌ی جداشده با فاصله را به‌عنوان یک آرگومان در نظر می‌گیرد. مثال زیر نحوه‌ی انجام این کار را نشان می‌دهد::"

msgid ""
"class MyArgumentParser(argparse.ArgumentParser):\n"
"    def convert_arg_line_to_args(self, arg_line):\n"
"        return arg_line.split()"
msgstr ""
"class MyArgumentParser(argparse.ArgumentParser):\n"
"    def convert_arg_line_to_args(self, arg_line):\n"
"        return arg_line.split()"

msgid "Note that with this override an argument can no longer contain spaces, since each space-separated word becomes a separate argument."
msgstr "توجه داشته باشید که با این بازنویسی، آرگومان دیگر نمی‌تواند شامل فاصله باشد، زیرا هر کلمه‌ای که با فاصله جدا شده باشد، به یک آرگومان جداگانه تبدیل می‌شود."

msgid "Exiting methods"
msgstr "متدهای خروج"

msgid "This method terminates the program, exiting with the specified *status* and, if given, it prints a *message* to :data:`sys.stderr` before that. The user can override this method to handle these steps differently::"
msgstr "این متد برنامه را با *status* مشخص خاتمه می‌دهد و در صورت ارائه شدن، پیش از آن یک *message* را در :data:`sys.stderr` چاپ می‌کند. کاربر می‌تواند این متد را بازنویسی کند تا این مراحل به شکل متفاوتی مدیریت شوند::"

msgid ""
"class ErrorCatchingArgumentParser(argparse.ArgumentParser):\n"
"    def exit(self, status=0, message=None):\n"
"        if status:\n"
"            raise Exception(f'Exiting because of an error: {message}')\n"
"        exit(status)"
msgstr ""
"class ErrorCatchingArgumentParser(argparse.ArgumentParser):\n"
"    def exit(self, status=0, message=None):\n"
"        if status:\n"
"            raise Exception(f'Exiting because of an error: {message}')\n"
"        exit(status)"

msgid "This method prints a usage message, including the *message*, to :data:`sys.stderr` and terminates the program with a status code of 2."
msgstr "این متد یک پیام کاربرد شامل *message* را در :data:`sys.stderr` چاپ می‌کند و برنامه را با کد وضعیت ۲ پایان می‌دهد."

msgid "Intermixed parsing"
msgstr "تجزیه درهم‌آمخته"

msgid "A number of Unix commands allow the user to intermix optional arguments with positional arguments.  The :meth:`~ArgumentParser.parse_intermixed_args` and :meth:`~ArgumentParser.parse_known_intermixed_args` methods support this parsing style."
msgstr "تعدادی از دستورهای یونیکس به کاربر اجازه می‌دهند آرگومان‌های اختیاری را با آرگومان‌های جایگاهی در هم بیامیزد. متدهای :meth:`~ArgumentParser.parse_intermixed_args` و :meth:`~ArgumentParser.parse_known_intermixed_args` از این سبک تجزیه پشتیبانی می‌کنند."

msgid "These parsers do not support all the :mod:`!argparse` features, and will raise exceptions if unsupported features are used.  In particular, subparsers, and mutually exclusive groups that include both optionals and positionals are not supported."
msgstr "این پارسرها از همه‌ی قابلیت‌های :mod:`!argparse` پشتیبانی نمی‌کنند و در صورت استفاده از قابلیت‌های پشتیبانی‌نشده، استثنا پرتاب می‌کنند. به‌طور خاص، زیرپارسرها و گروه‌های متقابلاً انحصاری که شامل هر دو آرگومان اختیاری و جایگاهی هستند، پشتیبانی نمی‌شوند."

msgid "The following example shows the difference between :meth:`~ArgumentParser.parse_known_args` and :meth:`~ArgumentParser.parse_intermixed_args`: the former returns ``['2', '3']`` as unparsed arguments, while the latter collects all the positionals into ``rest``.  ::"
msgstr "مثال زیر تفاوت میان :meth:`~ArgumentParser.parse_known_args` و :meth:`~ArgumentParser.parse_intermixed_args` را نشان می‌دهد: اولی ``['2', '3']`` را به‌عنوان آرگومان‌های تجزیه‌نشده برمی‌گرداند، در حالی که دومی همه‌ی آرگومان‌های جایگاهی را در ``rest`` جمع می‌کند.  ::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo')\n"
">>> parser.add_argument('cmd')\n"
">>> parser.add_argument('rest', nargs='*', type=int)\n"
">>> parser.parse_known_args('doit 1 --foo bar 2 3'.split())\n"
"(Namespace(cmd='doit', foo='bar', rest=[1]), ['2', '3'])\n"
">>> parser.parse_intermixed_args('doit 1 --foo bar 2 3'.split())\n"
"Namespace(cmd='doit', foo='bar', rest=[1, 2, 3])"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo')\n"
">>> parser.add_argument('cmd')\n"
">>> parser.add_argument('rest', nargs='*', type=int)\n"
">>> parser.parse_known_args('doit 1 --foo bar 2 3'.split())\n"
"(Namespace(cmd='doit', foo='bar', rest=[1]), ['2', '3'])\n"
">>> parser.parse_intermixed_args('doit 1 --foo bar 2 3'.split())\n"
"Namespace(cmd='doit', foo='bar', rest=[1, 2, 3])"

msgid ":meth:`~ArgumentParser.parse_known_intermixed_args` returns a two item tuple containing the populated namespace and the list of remaining argument strings. :meth:`~ArgumentParser.parse_intermixed_args` raises an error if there are any remaining unparsed argument strings."
msgstr ":meth:`~ArgumentParser.parse_known_intermixed_args` یک تاپل دو آیتمی شامل فضای نام پرشده و فهرست رشته‌های آرگومان باقی‌مانده را برمی‌گرداند. :meth:`~ArgumentParser.parse_intermixed_args` اگر رشته‌های آرگومان تجزیه‌نشده‌ی باقی‌مانده‌ای وجود داشته باشد، خطایی پرتاب می‌کند."

msgid "Registering custom types or actions"
msgstr "ثبت انواع سفارشی یا کنش‌های سفارشی"

msgid "Sometimes it's desirable to use a custom string in error messages to provide more user-friendly output. In these cases, :meth:`!register` can be used to register custom actions or types with a parser and allow you to reference the type by their registered name instead of their callable name."
msgstr "گاهی اوقات مطلوب است که در پیام‌های خطا از یک رشته سفارشی استفاده شود تا خروجی کاربر پسندتری ارائه شود. در این موارد، :meth:`!register` می‌تواند برای ثبت اکشن‌ها یا انواع سفارشی در یک پارسر استفاده شود و به شما امکان می‌دهد به جای نام شیء فراخوانی‌پذیر، به نوع با استفاده از نام ثبت‌شده‌ی آن ارجاع دهید."

msgid "The :meth:`!register` method accepts three arguments - a *registry_name*, specifying the internal registry where the object will be stored (e.g., ``action``, ``type``), *value*, which is the key under which the object will be registered, and object, the callable to be registered."
msgstr "متد :meth:`!register` سه آرگومان می‌پذیرد — *registry_name*، مشخص‌کننده‌ی رجیستری داخلی که شیء در آن ذخیره می‌شود (برای مثال ``action``، ``type``)، *value*، که کلیدی است که شیء با آن ثبت می‌شود، و object، شیء فراخوانی‌پذیر که باید ثبت شود."

msgid "The following example shows how to register a custom type with a parser::"
msgstr "مثال زیر نشان می‌دهد که چگونه می‌توان یک نوع سفارشی را در یک پارسر ثبت کرد::"

msgid ""
">>> import argparse\n"
">>> parser = argparse.ArgumentParser()\n"
">>> parser.register('type', 'hexadecimal integer', lambda s: int(s, 16))\n"
">>> parser.add_argument('--foo', type='hexadecimal integer')\n"
"_StoreAction(option_strings=['--foo'], dest='foo', nargs=None, const=None, default=None, type='hexadecimal integer', choices=None, required=False, help=None, metavar=None, deprecated=False)\n"
">>> parser.parse_args(['--foo', '0xFA'])\n"
"Namespace(foo=250)\n"
">>> parser.parse_args(['--foo', '1.2'])\n"
"usage: PROG [-h] [--foo FOO]\n"
"PROG: error: argument --foo: invalid 'hexadecimal integer' value: '1.2'"
msgstr ""
">>> import argparse\n"
">>> parser = argparse.ArgumentParser()\n"
">>> parser.register('type', 'hexadecimal integer', lambda s: int(s, 16))\n"
">>> parser.add_argument('--foo', type='hexadecimal integer')\n"
"_StoreAction(option_strings=['--foo'], dest='foo', nargs=None, const=None, default=None, type='hexadecimal integer', choices=None, required=False, help=None, metavar=None, deprecated=False)\n"
">>> parser.parse_args(['--foo', '0xFA'])\n"
"Namespace(foo=250)\n"
">>> parser.parse_args(['--foo', '1.2'])\n"
"usage: PROG [-h] [--foo FOO]\n"
"PROG: error: argument --foo: invalid 'hexadecimal integer' value: '1.2'"

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

msgid "An error from creating or using an argument (optional or positional)."
msgstr "خطایی ناشی از ایجاد یا استفاده از آرگومان (اختیاری یا جایگاهی)."

msgid "The string value of this exception is the message, augmented with information about the argument that caused it."
msgstr "مقدار رشته‌ای این استثنا، پیامی است که با اطلاعاتی درباره آرگومانی که باعث ایجاد آن شده، تکمیل‌شده است."

msgid "Raised when something goes wrong converting a command line string to a type."
msgstr "هنگامی که در تبدیل یک رشته‌ی خط فرمان به یک نوع، مشکلی پیش بیاید، پرتاب می‌شود."

msgid "Guides and Tutorials"
msgstr "راهنماها و آموزش‌ها"

msgid "? (question mark)"
msgstr "? (علامت سؤال)"

msgid "in argparse module"
msgstr "در ماژول argparse"

msgid "* (asterisk)"
msgstr "* (ستاره)"

msgid "+ (plus)"
msgstr "+ (مثبت)"

#~ msgid "If the user would like to enable suggestions for mistyped argument choices and subparser names, the feature can be enabled by setting ``suggest_on_error`` to ``True``. Note that this only applies for arguments when the choices specified are strings::"
#~ msgstr "اگر کاربر بخواهد پیشنهادها را برای انتخاب‌های آرگومان و نام‌های زیرپارسر (subparser) که اشتباه تایپ شده‌اند فعال کند، این قابلیت را می‌توان با تنظیم ``suggest_on_error`` روی ``True`` فعال کرد. توجه داشته باشید که این فقط برای آرگومان‌هایی اعمال می‌شود که انتخاب‌های تعیین‌شده برای آن‌ها رشته باشند::"

#~ msgid "If you're writing code that needs to be compatible with older Python versions and want to opportunistically use ``suggest_on_error`` when it's available, you can set it as an attribute after initializing the parser instead of using the keyword argument::"
#~ msgstr "اگر در حال نوشتن کدی هستید که باید با نسخه‌های قدیمی‌تر پایتون سازگار باشد و می‌خواهید در صورت در دسترس بودن، به‌صورت فرصت‌طلبانه از ``suggest_on_error`` استفاده کنید، می‌توانید به‌جای استفاده از آرگومان کلیدواژه‌ای، آن را پس از مقداردهی اولیه‌ی پارسر به‌عنوان یک ویژگی تنظیم کنید::"

#~ msgid ""
#~ ">>> parser = argparse.ArgumentParser(description='Process some integers.')\n"
#~ ">>> parser.suggest_on_error = True"
#~ msgstr ""
#~ ">>> parser = argparse.ArgumentParser(description='Process some integers.')\n"
#~ ">>> parser.suggest_on_error = True"

#~ msgid "Error messages will include color codes when redirecting stderr to a file. To avoid this, set the |NO_COLOR|_ or :envvar:`PYTHON_COLORS` environment variable (for example, ``NO_COLOR=1 python script.py 2> errors.txt``)."
#~ msgstr "در صورت هدایت stderr به یک پرونده، پیام‌های خطا شامل کدهای رنگ خواهند بود. برای جلوگیری از این موضوع، متغیر محیطی |NO_COLOR|_ یا :envvar:`PYTHON_COLORS` را تنظیم کنید (برای مثال، ``NO_COLOR=1 python script.py 2> errors.txt``)."

#~ msgid "Furthermore, :meth:`~_SubParsersAction.add_parser` supports an additional *aliases* argument, which allows multiple strings to refer to the same subparser. This example, like ``svn``, aliases ``co`` as a shorthand for ``checkout``::"
#~ msgstr "علاوه بر این، :meth:`~_SubParsersAction.add_parser` از یک آرگومان اضافی *aliases* پشتیبانی می‌کند، که امکان می‌دهد چندین رشته به یک زیرپارسر یکسان ارجاع داده شوند. این مثال، مانند ``svn``، نام مستعار ``co`` را به‌عنوان شکل کوتاهی برای ``checkout`` تعریف می‌کند::"

#~ msgid ":meth:`~_SubParsersAction.add_parser` supports also an additional *deprecated* argument, which allows to deprecate the subparser."
#~ msgstr ":meth:`~_SubParsersAction.add_parser` همچنین از یک آرگومان اضافی *deprecated* پشتیبانی می‌کند، که به شما امکان می‌دهد زیرپارسر (subparser) را منسوخ کنید."

#~ msgid "Note, the *default* will be ``None`` unless explicitly set to *0*."
#~ msgstr "توجه داشته باشید، *پیش‌فرض* ``None`` خواهد بود، مگر اینکه به‌صراحت روی *0* تنظیم شود."