Иметь парсер верхнего уровня и субпарсеры, работающие с одной и той же переменной

Желаемое поведение action='count' в соответствии с вопросом просто невозможно с использованием одного ArgumentParser (начиная с Python 3.12.3) из-за того, как подпространство имен в конце объединяется с основным пространством имен. В частности, внутренний вызываемый объект _CountAction попытается найти dest в текущем пространстве имен, установит для него значение 0, если оно еще не существует, и увеличит значение на 1. Однако внутренний вызываемый объект _SubparserAction просто наивно объединит полученные значения (не точная, но очень связанная известная проблема). Вы можете убедиться в этом, проследив выполнение с помощью следующего argparser (который настроен с дополнительными флагами по умолчанию для устранения неоднозначности вместе с примером входных данных) и пошагово пройдите через отладчик:

import argparse

common = argparse.ArgumentParser(add_help=False)
common.add_argument("-v", action = "count")
common.add_argument("-c", default = "common")

parser = argparse.ArgumentParser(parents=[common])
parser.add_argument("-p", default = "parser")
sub = parser.add_subparsers().add_parser("test", parents=[common])
sub.add_argument("-s", default = "sub")

args = ['-v', '-v', 'test', '-v', '-v']

# demo
print(f"parser: {parser.parse_args(args)}")

В качестве альтернативы шагу через отладчик вставьте print(namespace) над связанными строками для _CountAction.__call__ и print(f"{subnamespace} merging into {namespace}") перед блоком for во втором блоке кода, вы получите следующий вывод:

Namespace(v=None, c='common', p='parser')
Namespace(v=1, c='common', p='parser')
Namespace(v=None, c='common', s='sub')
Namespace(v=1, c='common', s='sub')
Namespace(v=2, c='common', s='sub') merging into Namespace(v=2, c='common', p='parser')
parser: Namespace(v=2, c='common', p='parser', s='sub')

Я работал над этой конкретной проблемой много лет назад в пакете, который я написал (в частности, этот коммит , который намекал на эту очень конкретную проблему), используя обычный синтаксический анализатор и parse_known_args с входящими аргументами. Поскольку в вашем последнем примере уже есть общий синтаксический анализатор, измените демонстрационную часть следующим образом:

print(f"common: {common.parse_known_args(args)}")
print(f"parser: {parser.parse_args(args)}")

Должен выдать следующий результат:

common: (Namespace(v=4, c='common'), ['test'])
parser: Namespace(v=2, c='common', p='parser', s='sub')

Выберите то, что вам нужно, из известных аргументов common (и игнорируйте остаток), проанализируйте список аргументов как обычно с помощью parser и используйте остальную часть как обычно.

Я знаю, что вы хотите избежать разных dest (почему?), но это кажется самым простым подходом. Это дает вам максимальный контроль.

In [4]: import argparse
   ...: 
   ...: parser = argparse.ArgumentParser()
   ...: parser.add_argument("-v", action = "count", dest='foo', default=0)
   ...: 
   ...: subparsers = parser.add_subparsers()
   ...: sub = subparsers.add_parser("test")
   ...: sub.add_argument("-v", action = "count", dest='subfoo', default=0);

In [5]: args = parser.parse_args(['-vv', 'test']); args
Out[5]: Namespace(foo=2, subfoo=0)

In [6]: args.count= args.foo+args.subfoo; args
Out[6]: Namespace(foo=2, subfoo=0, count=2)

In [7]: args = parser.parse_args(['test', '-vvv']); args
Out[7]: Namespace(foo=0, subfoo=3)

In [8]: args.count= args.foo+args.subfoo; args
Out[8]: Namespace(foo=0, subfoo=3, count=3)

In [9]: args = parser.parse_args(['-v','test', '-vvv']); args
Out[9]: Namespace(foo=1, subfoo=3)

In [10]: args.count= args.foo+args.subfoo; args
Out[10]: Namespace(foo=1, subfoo=3, count=4)

Как отмечалось ранее, значение subparser имеет приоритет. При вызове subparser получает новый Namespace, а не наследует тот, который использовался основными парсерами. По возвращении это подпространство имен используется для обновления основного пространства имен. Есть аргументы за и против этого выбора.

Выбирая разные dest, вы сохраняете контроль над тем, какой парсер имеет приоритет. Или в случае такого действия, как count способность относиться к ним одинаково. Стрелять, ты бы даже смог args.diff = args.foo - args.subfoo!

Для полноты картины я публикую свое фактическое решение, которое в значительной степени основано на принятом ответе:

def add_common_args(parser, defaults = {}):
    parser.add_argument("-v", "--verbose" action = "count")
    parser.add_argument("--foo")
    parser.set_defaults(**defaults)

common = argparse.ArgumentParser(add_help=False)
add_common_args(common)

parser = argparse.ArgumentParser(parents=[common])
subparsers = parser.add_subparsers()
p = subparsers.add_parser(subparsers, "test")
add_common_args(p, defaults_test)
p.add_argument("--bar")

# parse common args and subparser args separately
common_args = common.parse_known_args()[0]
args = parser.parse_args()

# fix common args
for k, v in common_args._get_kwargs():
    if v is None:
        continue
    setattr(args, k, v)

Хитрость заключается в том, чтобы (как предложил метатоастер) выполнить частичный анализ, который распознает только общие аргументы (игнорируя все неизвестное, например, сам субпарсер и конкретные аргументы субпарсера; но накапливая флаги count и гарантируя, что для обычных флагов побеждает последний).

Таким образом, прохождение -v --foo A test -v --foo B приведет к Namespace(v=2, foo='B', bar=None).

Чтобы добиться значений по умолчанию для каждого подпарсера (которые можно прочитать из файла конфигурации и, следовательно, они неизвестны), общие аргументы реализуются с помощью служебной функции add_common_args() (согласно предложению hpaulj), а не совместного использования common синтаксического анализатора. Нам нужно выделить неустановленные значения в особом случае из парсера common (if v is None: continue), чтобы значение по умолчанию не было перезаписано неустановленным значением.