Python argparse: Jak wstawić znak nowej linii w tekście pomocy?

Question

Używam argparse in Python 2.7 do analizowania opcji wprowadzania. Jedną z moich opcji jest wybór wielokrotny. Chcę utworzyć listę w tekście pomocy, np.

from argparse import ArgumentParser 

parser = ArgumentParser(description='test') 

parser.add_argument('-g', choices=['a', 'b', 'g', 'd', 'e'], default='a', 
    help="Some option, where\n" 
     " a = alpha\n" 
     " b = beta\n" 
     " g = gamma\n" 
     " d = delta\n" 
     " e = epsilon") 

parser.parse_args() 

Jednakże argparse usuwa wszystkie linie oraz kolejnych obszarów. Wynik wygląda tak, jak wstawić znaki nowej linii w tekście pomocy?

Answer 1

Spróbuj użyć RawTextHelpFormatter:

from argparse import RawTextHelpFormatter 
parser = ArgumentParser(description='test', formatter_class=RawTextHelpFormatter) 

Answer 2

Jeśli chcesz po prostu zastąpić jedną opcję, nie należy używać RawTextHelpFormatter. Zamiast podklasy HelpFormatter i zapewnić specjalny wstęp do opcji, które powinny być traktowane jako „raw” (używam "R|rest of help"):

import argparse 

class SmartFormatter(argparse.HelpFormatter): 

    def _split_lines(self, text, width): 
     if text.startswith('R|'): 
      return text[2:].splitlines() 
     # this is the RawTextHelpFormatter._split_lines 
     return argparse.HelpFormatter._split_lines(self, text, width) 

i używać go:

from argparse import ArgumentParser 

parser = ArgumentParser(description='test', formatter_class=SmartFormatter) 

parser.add_argument('-g', choices=['a', 'b', 'g', 'd', 'e'], default='a', 
    help="R|Some option, where\n" 
     " a = alpha\n" 
     " b = beta\n" 
     " g = gamma\n" 
     " d = delta\n" 
     " e = epsilon") 

parser.parse_args() 

Wszelkie inne połączenia do .add_argument() gdzie na pomoc nie zaczyna się od R| zostanie zapakowana jak zwykle. To jest częścią my improvements on argparse. Pełna funkcja SmartFormatter obsługuje także dodawanie ustawień domyślnych do wszystkich opcji oraz nieprzetworzone dane wejściowe opisu narzędzi. Pełna wersja ma własną metodę _split_lines, więc wszelkie formatowanie wykonane na przykład do ciągi wersji są zachowywane:

parser.add_argument('--version', '-v', action="version", 
        version="version...\n 42!") 

Answer 3

Napotkałem podobny problem (Python 2.7.6). Próbowałem rozbić opis rozdział na kilka linii z wykorzystaniem RawTextHelpFormatter:

parser = ArgumentParser(description="""First paragraph 

             Second paragraph 

             Third paragraph""", 
             usage='%(prog)s [OPTIONS]', 
             formatter_class=RawTextHelpFormatter) 

options = parser.parse_args() 

I got:

 
usage: play-with-argparse.py [OPTIONS] 

First paragraph 

         Second paragraph 

         Third paragraph 

optional arguments: 
    -h, --help show this help message and exit 

Więc RawTextHelpFormatter nie jest rozwiązaniem. Ponieważ wypisuje opis w postaci kodu źródłowego, zachowując wszystkie znaki odstępu (chcę zachować dodatkowe zakładki w moim kodzie źródłowym, aby móc je odczytać, ale nie chcę ich wszystkich drukować.) Również formatowanie raw nie owija wiersza, gdy jest on zbyt długi, na przykład ponad 80 znaków).

Dzięki @Anton, który zainspirował właściwy kierunek above. Ale to rozwiązanie wymaga niewielkich modyfikacji w celu sformatowania sekcji opis.

W każdym razie potrzebny jest niestandardowy formater. I przedłużony istniejących HelpFormatter klasę i overrode _fill_text metody takie jak to:

import textwrap as _textwrap 
class MultilineFormatter(argparse.HelpFormatter): 
    def _fill_text(self, text, width, indent): 
     text = self._whitespace_matcher.sub(' ', text).strip() 
     paragraphs = text.split('|n ') 
     multiline_text = '' 
     for paragraph in paragraphs: 
      formatted_paragraph = _textwrap.fill(paragraph, width, initial_indent=indent, subsequent_indent=indent) + '\n\n' 
      multiline_text = multiline_text + formatted_paragraph 
     return multiline_text 

porównać z oryginalnym kodem źródłowym pochodzące z modułu argparse:

def _fill_text(self, text, width, indent): 
    text = self._whitespace_matcher.sub(' ', text).strip() 
    return _textwrap.fill(text, width, initial_indent=indent, 
             subsequent_indent=indent) 

W oryginalnym kodzie cały opis jest zawinięty.W edytorze niestandardowym powyżej cały tekst jest podzielony na kilka części, a każdy z nich jest formatowany niezależnie.

Więc z pomocą niestandardowego formater:

parser = ArgumentParser(description= """First paragraph 
             |n        
             Second paragraph 
             |n 
             Third paragraph""", 
       usage='%(prog)s [OPTIONS]', 
       formatter_class=MultilineFormatter) 

options = parser.parse_args() 

wyjście jest:

 
usage: play-with-argparse.py [OPTIONS] 

First paragraph 

Second paragraph 

Third paragraph 

optional arguments: 
    -h, --help show this help message and exit 

Answer 4

Innym sposobem, aby to zrobić jest włączenie textwrap.

Na przykład

import argparse, textwrap 
parser = argparse.ArgumentParser(description='some information', 
     usage='use "python %(prog)s --help" for more information', 
     formatter_class=argparse.RawTextHelpFormatter) 

parser.add_argument('--argument', default=somedefault, type=sometype, 
     help= textwrap.dedent('''\ 
     First line 
     Second line 
     More lines ... ''')) 

W ten sposób możemy uniknąć długiej pustej przestrzeni z przodu każdej linii wyjściowej.

usage: use "python your_python_program.py --help" for more information 

Prepare input file 

optional arguments: 
-h, --help   show this help message and exit 
--argument ARGUMENT 
         First line 
         Second line 
         More lines ... 

Answer 5

Chciałam mieć zarówno ręczne podziały wierszy w tekście opisu, jak i jego automatyczne zawijanie; ale żadna z sugestii tutaj nie działała dla mnie - więc skończyłem na modyfikacji klasy SmartFormatter podanej w odpowiedziach tutaj; że problemy z argparse nazwy metod nie będący publicznym API pomimo, tutaj jest to, co mam (jako plik o nazwie test.py):

import argparse 
from argparse import RawDescriptionHelpFormatter 

# call with: python test.py -h 

class SmartDescriptionFormatter(argparse.RawDescriptionHelpFormatter): 
    #def _split_lines(self, text, width): # RawTextHelpFormatter, although function name might change depending on Python 
    def _fill_text(self, text, width, indent): # RawDescriptionHelpFormatter, although function name might change depending on Python 
    #print("splot",text) 
    if text.startswith('R|'): 
     paragraphs = text[2:].splitlines() 
     rebroken = [argparse._textwrap.wrap(tpar, width) for tpar in paragraphs] 
     #print(rebroken) 
     rebrokenstr = [] 
     for tlinearr in rebroken: 
     if (len(tlinearr) == 0): 
      rebrokenstr.append("") 
     else: 
      for tlinepiece in tlinearr: 
      rebrokenstr.append(tlinepiece) 
     #print(rebrokenstr) 
     return '\n'.join(rebrokenstr) #(argparse._textwrap.wrap(text[2:], width)) 
    # this is the RawTextHelpFormatter._split_lines 
    #return argparse.HelpFormatter._split_lines(self, text, width) 
    return argparse.RawDescriptionHelpFormatter._fill_text(self, text, width, indent) 

parser = argparse.ArgumentParser(formatter_class=SmartDescriptionFormatter, description="""R|Blahbla bla blah blahh/blahbla (bla blah-blabla) a blahblah bl a blaha-blah .blah blah 

Blah blah bla blahblah, bla blahblah blah blah bl blblah bl blahb; blah bl blah bl bl a blah, bla blahb bl: 

    blah blahblah blah bl blah blahblah""") 

options = parser.parse_args() 

Jak to działa w 2.7 i 3.4:

$ python test.py -h 
usage: test.py [-h] 

Blahbla bla blah blahh/blahbla (bla blah-blabla) a blahblah bl a blaha-blah 
.blah blah 

Blah blah bla blahblah, bla blahblah blah blah bl blblah bl blahb; blah bl 
blah bl bl a blah, bla blahb bl: 

    blah blahblah blah bl blah blahblah 

optional arguments: 
    -h, --help show this help message and exit