Привет. Недавно мне потребовалось пересобрать N парсеров в один. В нем должен быть родитель и N детей, а также возможность использовать функции сразу всех подпарсеров.

Спойлер: это было непросто! В статье расскажу о проблемах, с которыми столкнулся, а также объясню, как устроен модуль argparse в Python 3 и что он умеет.

Статья не про то, как написать свой первый парсер аргументов, используя этот модуль. И если вы не знаете Python на достаточно высоком уровне, понять некоторые особенности, описанные тут, будет сложно.

Проблема с использованием подпарсеров

Чтобы лучше разобраться в сути проблемы, следует рассмотреть самый базовый пример парсера, использующего дочерние элементы. Он будет взят из официальной документации:

import argparse
parser = argparse.ArgumentParser(prog='PROG')
parser.add_argument('--foo', action='store_true', help='foo help')

subparsers = parser.add_subparsers(help='sub-command help')

parser_a = subparsers.add_parser('a', help='a help')
parser_a.add_argument('-a', help='bar help')

parser_b = subparsers.add_parser('b', help='b help')
parser_b.add_argument('-b', help='baz help')

parser.parse_known_args(['a', '-a', '12', 'b', '-b', '32', '-d', '11'])
> Namespace(a=12) ['b', '-b', '32', '-d', '11']

Последняя строка в коде — результат выполнения программы. Проблема в том, что официальная документация гласит следующее:

То есть за один запуск программы невозможно получить значения всех дочерних парсеров без танцев с бубнами. Рассмотрим вышеописанный пример более скрупулезно — и все станет ясно.

import argparse
parser = argparse.ArgumentParser(prog='PROG') # Создаем "родительский" парсер.
parser.add_argument('--foo', action='store_true', help='foo help')

subparsers = parser.add_subparsers(help='sub-command help') # Создаем объект, отвечающий за создание дочерних парсеров.

parser_a = subparsers.add_parser('a', help='a help') # Инициализируем дочерний парсер.
parser_a.add_argument('-a', help='bar help')

parser_b = subparsers.add_parser('b', help='b help') # Инициализируем еще один дочерний парсер.
parser_b.add_argument('-b', help='baz help')

parser.parse_known_args(['a', '-a', '12', 'b', '-b', '32', '-d', '11']) # Вызываем метод родительского класса, отвечающий за парсинг всех объявленных аргументов. Было бы логично предположить, что на выходе мы получим кортеж, в котором будут содержаться значения подпарсеров. Что произойдет на самом деле - показано ниже ниже.
> Namespace(a=12) ['b', '-b', '32', '-d', '11'] # На выходе - кортеж, состоящий из так называемых Namespace, отвечающих за спаршенные аргументы и лист, отвечающий за лишние, неспаршенные аргументы соответственно.

И что с этим делать?

Проблему получения всех аргументов за один запуск программы можно решить несколькими способами. Мы рассмотрим два из них. 

Способ 1

Имея целочисленное количество существующих парсеров, можно N раз вызвать метод parse_known_args, передавая в качестве аргументов массив из лишних аргументов.

Решение выглядит так:
args, not_parsed = parser.parse_known_args(['a', '-a', '12', 'b', '-b', '32', '-d', '11']) - Получаем существующие аргументы и несуществующие.

args, not_parsed = parser.parse_known_args(not_parsed) - Передаем в метод полученные несуществующие элементы.

Да, оно работает. Однозначно. Однако мне кажется, так делать неправильно. Да, круто. Но мне совершенно не нравится, что я не могу получить все аргументы при попытке это сделать. Поэтому я решил раз и навсегда разобраться с этой проблемой и не только с ней, но еще и с алгоритмом работы argparse. В конце концов я прибегнул к способу 2. 

Итак, способ 2

Способ 2 заключается в том, чтоб сделать форк, изменив логику алгоритма argparse. Разбираем мотор на запчасти. Внутри protected-метода _parse_known_args создается цикл, определяющий, что из всего переданного нами является командами, а что — аргументами для каждой полученной команды:

for i, arg_string in enumerate(arg_strings_iter):

  # all args after -- are non-options
  if arg_string == '--':
    arg_string_pattern_parts.append('-')
    for arg_string in arg_strings_iter:
      arg_string_pattern_parts.append('A')

  # otherwise, add the arg to the arg strings
  # and note the index if it was an option
  else:
    option_tuple = self._parse_optional(arg_string)
    if option_tuple is None:
      pattern = 'A'
      else:
        option_string_indices[i] = option_tuple
        pattern = 'O'
        arg_string_pattern_parts.append(pattern)

Тут гвоздь программы — protected-метод _parse_optional, отвечающий непосредственно за полную проверку, что из переданного — команды, а что — аргументы. Если нашли команду во время парсинга, получаем на выходе O, во всех остальных случаях — A.

Далее происходит много сложных вычислений и запутанных циклов. Все они должны помочь программе определить нужность переданных аргументов, чтобы получить те самые known_args (известные аргументы). Но мы не будем останавливаться на этом цикле, поскольку проблема заключается не в нем. Перейдем к интересному замыканию, которое отвечает за инициализацию и вызов Actions: 

def take_action(action, argument_strings, option_string=None):
  seen_actions.add(action)
  argument_values = self._get_values(action, argument_strings)

  # error if this argument is not allowed with other previously
  # seen arguments, assuming that actions that use the default
  # value don't really count as "present"
  if argument_values is not action.default:
    seen_non_default_actions.add(action)
    for conflict_action in action_conflicts.get(action, []):
      if conflict_action in seen_non_default_actions:
        msg = _('not allowed with argument %s')
        action_name = _get_action_name(conflict_action)
        raise ArgumentError(action, msg % action_name)

  # take the action if we didn't receive a SUPPRESS value
  # (e.g. from a default)
  if argument_values is not SUPPRESS:
    action(self, namespace, argument_values, option_string)

Из этого кода нас больше всего интересует эта строка: action(self, namespace, argument_values, option_string).

Для полного понимания происходящего напомню, что все в Python является объектом. А поскольку все является объектом, то мы можем использовать это в своих целях. Например, чтобы передавать функции в качестве аргументов. Как так происходит? Все просто: функции — это объекты первого класса, то есть их можно передавать в качестве аргументов ровно так же, как и любые другие объекты.

Отличный пример такого объекта — действие action, которое передается в замыкание take_action. Причем это не функция, а полноценный класс, наследуемый от другого класса. А тот, в свою очередь, создан с помощью метакласса. Этот список можно продолжать долго, поверьте... Но вернемся к замыканию. В самом начале значение action будет равно _SubParsersAction. Именно этот объект, указывающий на _SubParsersAction, будет:
1) создан магическим методом new,
2) инициализирован при помощи конструктора init,
3) вызван при помощи call.

Все было бы просто, если бы в Python нельзя было переопределять и задавать поведение объектов при их создании. Я, наверное, тогда и не писал бы на «Хабр». Но раз статья увидела свет, значит, производить подобные махинации можно и даже нужно!

Рассмотрим хороший, на мой взгляд, пример использования магического метода, который позволил мне изменить поведение другого метода, о котором речь шла ранее, — parse_known_args:

    def __call__(self, parser, namespace, values, option_string=None):
parser_name = values[0]
arg_strings = values[1:]
    # set the parser name if requested
    if self.dest is not SUPPRESS:
        setattr(namespace, self.dest, parser_name)

    # select the parser
    try:
        parser = self._name_parser_map[parser_name]
    except KeyError:
        args = {'parser_name': parser_name,
                'choices': ', '.join(self._name_parser_map)}
        msg = _('unknown parser %(parser_name)r (choices: %(choices)s)') % args
        raise ArgumentError(self, msg)

    subnamespace, arg_strings = parser.parse_known_args(arg_strings, None)
    for key, value in vars(subnamespace).items():
        setattr(namespace, key, value)

    if arg_strings:
        vars(namespace).setdefault(_UNRECOGNIZED_ARGS_ATTR, [])
        getattr(namespace, _UNRECOGNIZED_ARGS_ATTR).extend(arg_strings)

Опять непонятный исходный код библиотеки без комментариев!

Я бы хотел дать вам какое-то время на размышления относительно того, что в этом методе не так. Подумайте и продолжайте читать.*

Теперь опишу происходящее тут.
После вызова класса мы получаем парсер, который создается путем вытаскивания первого значения из массива values и его подстановки в качестве ключа в словарь, содержащий в себе информацию о созданных подпарсерах: self._name_parser_map[parser_name]. На выходе — объект, хранящий в себе action для парсинга первого (нулевого) аргумента. И это, пожалуй, одна из самых важных частей описанного метода, так как при создании нового parser в нем создается _StoreAction, который призван хранить необходимые аргументы и отвечает за последующий парсинг.

Затем происходит повторный вызов parser.parse_known_args(arg_strings, None), но уже для вновь созданного объекта parser. Внутри него определяются необходимые значения из массива values, а остальные заносятся в arg_strings. Они считаются ненужными и больше нигде не используются — в этом и проблема. 

Проще говоря, _SubParsersAction хранит в себе кучу actions, которые мы создавали путем инициализации подпарсеров, но в виде выбора — собственно, само поле так и называется.

По итогу берется первый Action из этой выборки, полностью и целиком парсится согласно всем правилам, которые составил разработчик. Почему все устроено так, что берется только первый Action из выборки? Расскажу об этом в конце.

Хеппи-энд, или Еще немного о способе 2 

В общем, сделал форк и готов поделиться им с вами:

    def __call__(self, parser, namespace, values, option_string=None, arg_strings_pattern:list =None):
        o_amount = arg_strings_pattern.count("O")
        if not o_amount:
            raise ValueError("No Os found")
        o_start, o_stop, indexes = arg_strings_pattern.index('O'), len(arg_strings_pattern), []
        print(parser)
        try:
            while arg_strings_pattern.index('O', o_start, o_stop):
                indexes.append(arg_strings_pattern.index('O', o_start, o_stop))
                o_start = arg_strings_pattern.index('O', o_start + 1, o_stop)
        except ValueError:
            pass

        used_indexes = []
        known_args = {}
        for i, index in enumerate(indexes):
            parser_name = values[index - 1]
            if not known_args.get(parser_name):
                known_args[parser_name] = []
                known_args[parser_name] += values[index: indexes[i + 1] - 1] if i + 1 < len(indexes) else values[index:]
            if index not in used_indexes:
                for s, subindex in enumerate(indexes[1:]):
                    subparser_name = values[subindex - 1]
                    if parser_name == subparser_name:
                        used_indexes.append(index)
                        used_indexes.append(subindex)
                        subparser_args = values[subindex: indexes[s + 2] - 1] if s + 2 < len(indexes) else values[subindex:]
                        known_args[parser_name] += subparser_args

        for parser_name, args in known_args.items():
            self._create_parser(namespace, parser_name, args)

    def _create_parser(self, namespace, parser_name, arg_strings):

        if self.dest is not SUPPRESS:
            setattr(namespace, self.dest, parser_name)

        try:
            parser = self._name_parser_map[parser_name]
        except KeyError:
            args = {'parser_name': parser_name,
                    'choices': ', '.join(self._name_parser_map)}
            msg = _('unknown parser %(parser_name)r (choices: %(choices)s)') % args
            raise ArgumentError(self, msg)

        subnamespace, arg_strings = parser.parse_known_args(arg_strings, None)
        for key, value in vars(subnamespace).items():
            setattr(namespace, key, value)

        if arg_strings:
            vars(namespace).setdefault(_UNRECOGNIZED_ARGS_ATTR, [])
            getattr(namespace, _UNRECOGNIZED_ARGS_ATTR).extend(arg_strings)

Выше я говорил, что мы в какой-то момент можем получить строку вида AAAAOAAAOAA. Так вот, эта строка меня сильно выручила. Я почти сдался, пока разгадывал, как лучше изменить алгоритм, ничего не сломав. Выходит, что изначально уже есть информация, где именно находится команда, где находятся ее аргументы и так далее.

В этом форке я создаю по объекту-парсеру, выясняя из изначально полученных значений, что именно является показателем вновь созданного аргумента, а что, соответственно, нет. Затем определяю границы и по ним получаю необходимые аргументы, которые в дальнейшем будут переданы в функцию по созданию объекта-парсера:

	o_amount = arg_strings_pattern.count("O")
	if not o_amount:
		raise ValueError("No Os found")
	o_start, o_stop, indexes = arg_strings_pattern.index('O'), len(arg_strings_pattern), []
	try:
		while arg_strings_pattern.index('O', o_start, o_stop):
			indexes.append(arg_strings_pattern.index('O', o_start, o_stop))
			o_start = arg_strings_pattern.index('O', o_start + 1, o_stop)
	except ValueError:
		pass

Таким образом, у меня есть индексы всех команд и возможность вычислить количество аргументов — нужно взять медиану между индексами команд, при этом не выходя за границы массива values:

	used_indexes = []
	known_args = {}
	for i, index in enumerate(indexes):
		parser_name = values[index - 1]
		if not known_args.get(parser_name):
			known_args[parser_name] = []
			known_args[parser_name] += values[index: indexes[i + 1] - 1] if i + 1 < len(indexes) else values[index:]
		if index not in used_indexes:
			for s, subindex in enumerate(indexes[1:]):
				subparser_name = values[subindex - 1]
				if parser_name == subparser_name:
					used_indexes.append(index)
					used_indexes.append(subindex)
					subparser_args = values[subindex: indexes[s + 2] - 1] if s + 2 < len(indexes) else values[subindex:]
					known_args[parser_name] += subparser_args

	for parser_name, args in known_args.items():
		self._create_parser(namespace, parser_name, args)

Дальше я разделил методы для более красивого вызова. Просто вызвал оставшуюся, старую часть.

Выше я говорил, что пытался переработать алгоритм и ничего не сломать. Что же, алгоритм я переработал и почти ничего не сломал. Так как теперь мы разбираем сразу все аргументы, то на выходе не получаем ничего лишнего, ведь лишнего формально не остается.

Это, конечно, можно как-то исправить, но в рамках моего проекта текущей функциональности более чем достаточно и, думаю, в рамках каких-то других тоже. Будет не так здорово, если кому-то необходимо, чтобы при парсинге с помощью этого метода для каждой команды еще и отдавались лишние аргументы.

Подобные проблемы были описаны и ранее. Никто не понимал, почему это не работает нормально и почему значения подпарсеров не парсятся сразу.

Проблема решена — время двигаться дальше, к теме пересборки парсеров.

Проблема пересборки: как это вообще работает

У каждого объекта-парсера есть actions, которые говорят парсеру, что делать с переданными в него данными, например: 

• _HelpActions, отвечающие за вывод help;

• _StoreActions, отвечающие за создание функции, позволяющей нам хранить переданные пользователем данные.

Нам интересны _StoreActions. Давайте еще раз рассмотрим базовый пример создания подпарсера:

parser = argparse.ArgumentParser(prog='PROG')
parser.add_argument('--foo', action='store_true', help='foo help')

subparsers = parser.add_subparsers(help='sub-command help')

parser_a = subparsers.add_parser('a', help='a help')
parser_a.add_argument('-a', help='bar help')

parser_b = subparsers.add_parser('b', help='b help')
parser_b.add_argument('-b', help='baz help')

Из важного надо выделить следующие строки:

parser = argparse.ArgumentParser(prog='PROG') # Создаем родительский парсер
subparsers = parser.add_subparsers(help='sub-command help') # Создаем объект, отвечающий за добавление дочерних парсеров
parser_a = subparsers.add_parser('a', help='a help') # инициализируем новый дочерний парсер
...

Теперь представим ситуацию: кто-то написал 20 парсеров, и нам необходимо интегрировать их в один основной. Да, задача нетривиальная, но, как видите, случается.

Как это сделать:
1. Создать родительский парсер.
2. Получить все объекты-парсеры.
3. Инициализировать подпарсер.
4. Пройтись циклом по всем (пока еще не дочерним) объектам-парсерам:
4.1. Инициализировать новый подпарсер.
4.2. Взять _actions  из уже созданного парсера, который был передан нам.
4.3. Интегрировать эти _actions в дочерний парсер.

Сейчас все это хранится у меня на GitHub и выглядит примерно так:

import argparse
from PluginHandler import AnotherPlugin


class ParserMetaclass(type):
    def __new__(mcs, name, bases, dct):
        if name != "ArgumentParser":
            if not dct.get("_PluginLink"):
                raise LookupError(f"Link in {mcs} for parent class not found. Terminating")
            if not dct.get("__plugin_name__"):
                dct["__plugin_name__"] = name
                print(name)
        parser_object = type.__new__(mcs, name, bases, dct)
        return parser_object


class ArgumentParser(metaclass=ParserMetaclass):
    """
    # Every plugin class should have:
    # _PluginLink = Plugin, where
    # _PluginLink is basic link to object
    # __plugin_name__ -> name, that could
    # allow you to use your own parser
    # from parent one.

    # Every class should have
    # __parser__name__
    # otherwise plugin subparser
    # call name will be generated
    # from className

    # The only problem is in conflict
    # The only way (as i think) is to use
    # conflict_handler='resolve' handler
    # that will by default resolve all
    # conflicts in the program.

    # If you don't want to auto editing, <- TODO
    # just inherit from this class and change
    # parser options like this:
    # https://docs.python.org/3/library/argparse.html#other-utilities
    """

    test = "test"

    def __init__(self):
        self.parent_parser = argparse.ArgumentParser(conflict_handler='resolve')

    def __recreate_parser(self, created_parsers: dict):
        """
        Example parser ._actions:
        _HelpAction(option_strings=['-h', '--help'], dest='help', nargs=0, const=None, default='==SUPPRESS==', type=None,
        choices=None, help='show this help message and exit', metavar=None)
        _StoreAction(option_strings=['-t', '--test'], dest='test', nargs=None, const=None, default=None, type=None,
        choices=None, help=None, metavar=None)
        _StoreAction(option_strings=['-p', '--plugin'], dest='plugin', nargs=None, const=None, default=None, type=None,
        choices=None, help=None, metavar=None)

        So this method is created for recreation of parser to insert it into the "parent"
        :param created_parser:
        :return:
        """
        subparsers = self.parent_parser.add_subparsers()

        for parser, name in created_parsers.items():
            if isinstance(parser, argparse.ArgumentParser):
                """
                We could use parser._option_string_actions
                But afterwards there is pretty hard way to resolve
                all argparse objects. So that's is optimal way 
                """
                parser_actions = parser._actions
                if parser_actions:
                    plugin_subparser = subparsers.add_parser(name=name)
                    for action in parser_actions:
                        action_kwargs = dict(action._get_kwargs())
                        if isinstance(action, argparse._HelpAction):
                            """
                            Passing this _HelpAction because of every 
                            _*StoreAction is linked to it's own _HelpAction
                            """
                            continue
                        """
                        From lib source:
    
                                # if no positional args are supplied or only one is supplied and
                                # it doesn't look like an option string, parse a positional
                                # argument
                        
                        >> return dict(kwargs, dest=dest, option_strings=[])
                        
                        So option_strings will be empty.
                        """
                        options = action_kwargs['option_strings']
                        action_kwargs.pop('option_strings')
                        plugin_subparser.add_argument(*options, **action_kwargs)

Это решение позволяет динамически создавать N подпарсеров в зависимости от ваших нужд. А вместе с форком это даст возможность использовать плагины и для каждого из них задавать свои аргументы.

Выглядит решение в общей сумме так:

import argfork as argparse

from PluginsArgumentParser import ArgumentParser

pars = ArgumentParser()

test1 = argparse.ArgumentParser()
test1.add_argument("-t")

test2 = argparse.ArgumentParser()
test2.add_argument("-r")

test3 = argparse.ArgumentParser()
test3.add_argument("-b")

res_dict = {
    test1: "Plugin1",
    test2: "Plugin2",
    test3: "Plugin3"
}

pars.setup(res_dict)
args, unk_args = (pars.parent_parser.parse_known_args(
    ["Plugin1", '-t', '1', "Plugin2", '-r', '2', "Plugin3", '-b', '3']
))

Сравнение работы парсера до и после переработки

Посмотрим, как с поставленной задачей справляется argparse без исправлений:

import argparse

parser = argparse.ArgumentParser(prog='PROG')
subparsers = parser.add_subparsers(help='sub-command help')

# create the parser for the "a" command
parser_a = subparsers.add_parser('a', help='a help')
parser_a.add_argument('-a', help='bar help')

# create the parser for the "b" command
parser_b = subparsers.add_parser('b', help='b help')
parser_b.add_argument('-b', help='baz help')

# parse some argument lists
args, unk_args = (parser.parse_known_args(['a', '-a', '12', 'b', '-b', '32',]))
# args, unk_args = (parser.parse_known_args(unk_args))
print(args, unk_args)

На выходе: Namespace(a='12', foo=False) ['b', '-b', '32'] — то есть спарсилось только одно значение.

Теперь, используя форк import argfork as argparse: Namespace(a='12', b='32') [], мы получили все инициализированные значения подпарсеров.

Самые наблюдательные наверняка заметили, что из вывода в форке пропало значение foo=False. Это решение создано исключительно для работы с N дочерних парсеров и не работает в случае, когда необходимо получить значения родительского парсера вкупе со значениями дочерних. Можно, конечно, передать в качестве первого аргумента значение родительского, но тогда дочерние рассматриваться не будут.

Простые юнит-тесты, которые демонстрируют работоспособность:

import unittest
import argfork as argparse
from argfork import Namespace

class argparseTest(unittest.TestCase):
  def setUp(self) -> None:
      self.parser = argparse.ArgumentParser(prog='PROG')
      subparsers = self.parser.add_subparsers(help='sub-command help')

      # create the parser for the "a" command
      parser_a = subparsers.add_parser('a', help='a help')
      parser_a.add_argument('-a', help='bar help')

      # create the parser for the "b" command
      parser_b = subparsers.add_parser('b', help='b help')
      parser_b.add_argument('-b', help='baz help')
      parser_b.add_argument('-q', help='baz help')

      # create the parser for the "c" command
      parser_b = subparsers.add_parser('c', help='b help')
      parser_b.add_argument('-c', help='baz help')
      parser_b.add_argument('-k', help='baz help')

      # create the parser for the "c" command
      parser_b = subparsers.add_parser('d', help='b help')
      parser_b.add_argument('-d', help='baz help')
      parser_b.add_argument('-D', help='baz help')
      parser_b.add_argument('-R', help='baz help')

  def testSimple(self):
      case = ['a', '-a', 'test']
      res_obj = Namespace(a='test').__dict__
      rest_obj = self.parser.parse_known_args(case)[0].__dict__

      res_k, res_v = res_obj.keys(), list(res_obj.values())
      test_k, test_v = rest_obj.keys(), list(rest_obj.values())

      self.assertEqual(res_v, test_v)
      self.assertEqual(res_k, test_k)

  def testMany(self):
      case = ['d', '-d', '1234', 'd', '-D', '12345', 'd', '-R', '1', 'c', '-c', '123', 'c', '-k', '555', 'b', '-q', 'test']
      res_obj = Namespace(d='1234', D='12345', R='1', c='123', k='555', b=None, q='test').__dict__
      rest_obj = self.parser.parse_known_args(case)[0].__dict__

      res_k, res_v = res_obj.keys(), list(res_obj.values())
      test_k, test_v = rest_obj.keys(), list(rest_obj.values())

      self.assertEqual(res_v, test_v)
      self.assertEqual(res_k, test_k)

  def testZero(self):
      case = []
      res_obj = Namespace().__dict__
      rest_obj = self.parser.parse_known_args(case)[0].__dict__

      res_k, res_v = res_obj.keys(), list(res_obj.values())
      test_k, test_v = rest_obj.keys(), list(rest_obj.values())

      self.assertEqual(res_v, test_v)
      self.assertEqual(res_k, test_k)

if name == 'main':
unittest.main()

На выходе:Ran 3 tests in 0.007s OK

Получается, что я больше не хочу играть со стандартным argparse.

Связаться со мной

Телеграм канал: https://t.me/r1v3ns_life
Сорцы: https://github.com/rive-n/Gitlab-exploitation-toolkit
Я: https://t.me/rive_n