feat: portage to tiramisu 5.0

README.md

@@ -11,7 +11,9 @@ Let us start with a simple example
 
 from tiramisu_cmdline_parser import TiramisuCmdlineParser
 from tiramisu import IntOption, StrOption, BoolOption, ChoiceOption, \
-                     SymLinkOption, OptionDescription, Config
+                     SymLinkOption, OptionDescription, \
+                     Config, Calculation, Params, ParamValue, ParamOption, \
+                     calc_value
 # build a Config with:
 # * a choice for select a sub argument (str, list, int)
 choiceoption = ChoiceOption('cmd',
@@ -27,28 +29,37 @@ short_booloption = SymLinkOption('v', booloption)
 # * a string option if cmd is 'str'
 str_ = StrOption('str',
                  'string option',
-                 properties=('mandatory',),
+                 properties=('mandatory',
-                 requires=[{'option': choiceoption,
+                             Calculation(calc_value,
-                            'expected': 'str',
+                                         Params(ParamValue('disabled'),
-                            'action': 'disabled',
+                                                kwargs={'condition': ParamOption(choiceoption),
-                            'inverse': True}])
+                                                        'reverse_condition': ParamValue(True),
+                                                        'expected': ParamValue('str')})),
+                             ),
+                 )
 # * a list of strings option if cmd is 'list'
 list_ = StrOption('list',
                   'list string option',
                   multi=True,
-                  properties=('mandatory',),
+                  properties=('mandatory',
-                  requires=[{'option': choiceoption,
+                              Calculation(calc_value,
-                             'expected': 'list',
+                                          Params(ParamValue('disabled'),
-                             'action': 'disabled',
+                                                 kwargs={'condition': ParamOption(choiceoption),
-                             'inverse': True}])
+                                                         'reverse_condition': ParamValue(True),
+                                                         'expected': ParamValue('list')})),
+                              ),
+                 )
 # * an integer option if cmd is 'int'
 int_ = IntOption('int',
                  'int option',
-                 properties=('mandatory',),
+                  properties=('mandatory',
-                 requires=[{'option': choiceoption,
+                              Calculation(calc_value,
-                            'expected': 'int',
+                                          Params(ParamValue('disabled'),
-                            'action': 'disabled',
+                                                 kwargs={'condition': ParamOption(choiceoption),
-                            'inverse': True}])
+                                                         'reverse_condition': ParamValue(True),
+                                                         'expected': ParamValue('int')})),
+                              ),
+                 )
 # Now build Config
 config = Config(OptionDescription('root',
                                   'root',
@@ -67,62 +78,75 @@ parser.parse_args()
 # now, print the result
 print('result:')
 config.property.read_only()
-for key, value in config.value.dict().items():
+def display(data):
-    print('- {} ({}): {}'.format(key,
+    for key, value in data.items():
-                                 config.option(key).option.doc(),
+        if key.isoptiondescription():
-                                 value))
+            display(value)
+        else:
+            print(f'- {key.path()} ({key.description()}): {value}')
+display(config.value.get())
 ```
 
 Let's print help:
 
 ```bash
-[gnunux@localhost tiramisu-parser]$ python3 prog.py str -h
+$ python3 prog.py -h
-usage: prog.py [-h] [-v] --str STR --list LIST [LIST ...] --int INT
+usage: prog.py [-h] [-v] [-nv] {str,list,int}
-               {str,list,int}
 
 positional arguments:
   {str,list,int}       choice the sub argument
 
-optional arguments:
+options:
   -h, --help           show this help message and exit
   -v, --verbosity      increase output verbosity
-  --str STR             string option
+  -nv, --no-verbosity
-  --list LIST [LIST ...]
-                        list string option
-  --int INT             int option
 ```
 
 The positional argument 'cmd' is mandatory:
 
 ```bash
-[gnunux@localhost tiramisu-parser]$ python3 prog.py
+$ python3 prog.py
-usage: prog.py [-h] [-v] --str STR --list LIST [LIST ...] --int INT
+usage: prog.py [-h] [-v] [-nv] {str,list,int}
-               {str,list,int}
 prog.py: error: the following arguments are required: cmd
 ```
 
 If 'cmd' is 'str', --str become mandatory:
 
 ```bash
-[gnunux@localhost tiramisu-parser]$ python3 prog.py str
+$ python3 prog.py str
 usage: prog.py [-h] [-v] --str STR --list LIST [LIST ...] --int INT
                {str,list,int}
 prog.py: error: the following arguments are required: --str
 ```
 
+Here is help:
+
+```bash
+$ python3 prog.py str -h
+usage: prog.py "str" [-h] [-v] [-nv] --str STR {str,list,int}
+
+positional arguments:
+  {str,list,int}       choice the sub argument
+
+options:
+  -h, --help           show this help message and exit
+  -v, --verbosity      increase output verbosity
+  -nv, --no-verbosity
+  --str STR            string option
+```
+
 If 'cmd' is 'str', cannot set --int argument:
 
 ```bash
-[gnunux@localhost tiramisu-parser]$ python3 prog.py str --int 3
+$ python3 prog.py str --int 3
-usage: prog.py [-h] [-v] --str STR --list LIST [LIST ...] --int INT
+usage: prog.py "str" [-h] [-v] [-nv] --str STR {str,list,int}
-               {str,list,int}
 prog.py: error: unrecognized arguments: --int
 ```
 
 With all mandatories arguments:
 
 ```bash
-[gnunux@localhost tiramisu-parser]$ python3 prog.py str --str value
+$ python3 prog.py str --str value
 result:
 - cmd (choice the sub argument): str
 - verbosity (increase output verbosity): False
@@ -131,7 +155,7 @@ result:
 ```
 
 ```bash
-[gnunux@localhost tiramisu-parser]$ python3 prog.py int --int 3
+$ python3 prog.py int --int 3
 result:
 - cmd (choice the sub argument): int
 - verbosity (increase output verbosity): False
@@ -140,7 +164,7 @@ result:
 ```
 
 ```bash
-[gnunux@localhost tiramisu-parser]$ python3 prog.py list --list a b c
+$ python3 prog.py list --list a b c
 result:
 - cmd (choice the sub argument): list
 - verbosity (increase output verbosity): False
@@ -151,13 +175,13 @@ result:
 Add --verbosity argument:
 
 ```bash
-[gnunux@localhost tiramisu-parser]$ python3 prog.py list --list a b c -v
+$ python3 prog.py list --list a b c -v
 result:
 - cmd (choice the sub argument): list
 - verbosity (increase output verbosity): True
 - v (increase output verbosity): True
 - list (list string option): ['a', 'b', 'c']
-[gnunux@localhost tiramisu-parser]$ python3 prog.py list --list a b c --verbosity
+$ python3 prog.py list --list a b c --verbosity
 result:
 - cmd (choice the sub argument): list
 - verbosity (increase output verbosity): True

setup.py

@@ -15,7 +15,7 @@ setup(
     description="command-line parser using Tiramisu.",
 	url='https://framagit.org/tiramisu/tiramisu-cmdline-parser',
     license='GNU Library or Lesser General Public License (LGPL)',
-    install_requires=["tiramisu_api>=0.1"],
+    install_requires=["tiramisu>=5.0"],
 	classifiers=[
         "Programming Language :: Python :: 3",
         "License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)",

tests/test_choice.py

@@ -7,10 +7,12 @@ from tiramisu_cmdline_parser import TiramisuCmdlineParser
 from tiramisu import ChoiceOption, OptionDescription, Config
 try:
     from tiramisu_api import Config as JsonConfig
-    params = ['tiramisu', 'tiramisu-json']
+    #params = ['tiramisu', 'tiramisu-json']
+    params = ['tiramisu']
 except:
     params = ['tiramisu']
 
+from .utils import TestHelpFormatter, to_dict
 
 
 def get_config(json):
@@ -39,7 +41,7 @@ def get_config(json):
     config.property.read_write()
     if json == 'tiramisu':
         return config
-    jconfig = JsonConfig(config.option.dict())
+    jconfig = JsonConfig(config.option.get())
     return jconfig
 
 
@@ -49,20 +51,16 @@ def json(request):
 
 
 def test_choice_positional(json):
-    output1 = '''usage: prog.py "str" "1" [-h] [--str {str1,str2,str3}] [--int {1,2,3}]
+    output1 = '''usage: prog.py "str" "1" [-h] [--str {str1,str2,str3}] [--int {1,2,3}] [--int_multi [{1,2,3} ...]] {str,list,int,none} {1,2,3}
-                         [--int_multi [{1,2,3} [{1,2,3} ...]]]
-                         {str,list,int,none} {1,2,3}
 prog.py: error: argument positional: invalid choice: 'error' (choose from 'str', 'list', 'int', 'none')
 '''
-    output2 = '''usage: prog.py "str" "1" [-h] [--str {str1,str2,str3}] [--int {1,2,3}]
+    output2 = '''usage: prog.py "str" "1" [-h] [--str {str1,str2,str3}] [--int {1,2,3}] [--int_multi [{1,2,3} ...]] {str,list,int,none} {1,2,3}
-                         [--int_multi [{1,2,3} [{1,2,3} ...]]]
-                         {str,list,int,none} {1,2,3}
 prog.py: error: argument positional_int: invalid choice: '4' (choose from '1', '2', '3')
 '''
     config = get_config(json)
-    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser = TiramisuCmdlineParser(config, 'prog.py', formatter_class=TestHelpFormatter)
     parser.parse_args(['str', '1'])
-    assert config.value.dict() == {'positional': 'str',
+    assert to_dict(config.value.get()) == {'positional': 'str',
                                    'positional_int': 1,
                                    'str': None,
                                    'int': None,
@@ -89,28 +87,25 @@ prog.py: error: argument positional_int: invalid choice: '4' (choose from '1', '
 
 
 def test_choice_str(json):
-    output = """usage: prog.py "str" "1" --str "str3" [-h] [--str {str1,str2,str3}]
+    output = """usage: prog.py "str" "1" --str "str3" [-h] [--str {str1,str2,str3}] [--int {1,2,3}] [--int_multi [{1,2,3} ...]] {str,list,int,none} {1,2,3}
-                                      [--int {1,2,3}]
-                                      [--int_multi [{1,2,3} [{1,2,3} ...]]]
-                                      {str,list,int,none} {1,2,3}
 prog.py: error: argument --str: invalid choice: 'error' (choose from 'str1', 'str2', 'str3')
 """
     config = get_config(json)
-    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser = TiramisuCmdlineParser(config, 'prog.py', formatter_class=TestHelpFormatter)
     parser.parse_args(['str', '1', '--str', 'str1'])
-    assert config.value.dict() == {'positional': 'str',
+    assert to_dict(config.value.get()) == {'positional': 'str',
                                    'positional_int': 1,
                                    'str': 'str1',
                                    'int': None,
                                    'int_multi': []}
     parser.parse_args(['str', '1', '--str', 'str2'])
-    assert config.value.dict() == {'positional': 'str',
+    assert to_dict(config.value.get()) == {'positional': 'str',
                                    'positional_int': 1,
                                    'str': 'str2',
                                    'int': None,
                                    'int_multi': []}
     parser.parse_args(['str', '1', '--str', 'str3'])
-    assert config.value.dict() == {'positional': 'str',
+    assert to_dict(config.value.get()) == {'positional': 'str',
                                    'positional_int': 1,
                                    'str': 'str3',
                                    'int': None,
@@ -124,7 +119,7 @@ prog.py: error: argument --str: invalid choice: 'error' (choose from 'str1', 'st
         else:
             raise Exception('must raises')
     assert f.getvalue() == output
-    assert config.value.dict() == {'positional': 'str',
+    assert to_dict(config.value.get()) == {'positional': 'str',
                                    'positional_int': 1,
                                    'str': 'str3',
                                    'int': None,
@@ -132,16 +127,13 @@ prog.py: error: argument --str: invalid choice: 'error' (choose from 'str1', 'st
 
 
 def test_choice_int(json):
-    output = """usage: prog.py "str" "1" --int "1" [-h] [--str {str1,str2,str3}]
+    output = """usage: prog.py "str" "1" --int "1" [-h] [--str {str1,str2,str3}] [--int {1,2,3}] [--int_multi [{1,2,3} ...]] {str,list,int,none} {1,2,3}
-                                   [--int {1,2,3}]
-                                   [--int_multi [{1,2,3} [{1,2,3} ...]]]
-                                   {str,list,int,none} {1,2,3}
 prog.py: error: argument --int: invalid choice: '4' (choose from '1', '2', '3')
 """
     config = get_config(json)
-    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser = TiramisuCmdlineParser(config, 'prog.py', formatter_class=TestHelpFormatter)
     parser.parse_args(['str', '1', '--int', '1'])
-    assert config.value.dict() == {'positional': 'str',
+    assert to_dict(config.value.get()) == {'positional': 'str',
                                    'positional_int': 1,
                                    'str': None,
                                    'int': 1,
@@ -155,7 +147,7 @@ prog.py: error: argument --int: invalid choice: '4' (choose from '1', '2', '3')
         else:
             raise Exception('must raises')
     assert f.getvalue() == output
-    assert config.value.dict() == {'positional': 'str',
+    assert to_dict(config.value.get()) == {'positional': 'str',
                                    'positional_int': 1,
                                    'str': None,
                                    'int': 1,
@@ -163,16 +155,13 @@ prog.py: error: argument --int: invalid choice: '4' (choose from '1', '2', '3')
 
 
 def test_choice_int_multi(json):
-    output = """usage: prog.py "str" "1" --int_multi "1" "2" [-h] [--str {str1,str2,str3}]
+    output = """usage: prog.py "str" "1" --int_multi "1" "2" [-h] [--str {str1,str2,str3}] [--int {1,2,3}] [--int_multi [{1,2,3} ...]] {str,list,int,none} {1,2,3}
-                                             [--int {1,2,3}]
-                                             [--int_multi [{1,2,3} [{1,2,3} ...]]]
-                                             {str,list,int,none} {1,2,3}
 prog.py: error: argument --int_multi: invalid choice: '4' (choose from '1', '2', '3')
 """
     config = get_config(json)
-    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser = TiramisuCmdlineParser(config, 'prog.py', formatter_class=TestHelpFormatter)
     parser.parse_args(['str', '1', '--int_multi', '1', '2'])
-    assert config.value.dict() == {'positional': 'str',
+    assert to_dict(config.value.get()) == {'positional': 'str',
                                    'positional_int': 1,
                                    'str': None,
                                    'int': None,
@@ -186,7 +175,7 @@ prog.py: error: argument --int_multi: invalid choice: '4' (choose from '1', '2',
         else:
             raise Exception('must raises')
     assert f.getvalue() == output
-    assert config.value.dict() == {'positional': 'str',
+    assert to_dict(config.value.get()) == {'positional': 'str',
                                    'positional_int': 1,
                                    'str': None,
                                    'int': None,
@@ -200,7 +189,7 @@ prog.py: error: argument --int_multi: invalid choice: '4' (choose from '1', '2',
         else:
             raise Exception('must raises')
     assert f.getvalue() == output
-    assert config.value.dict() == {'positional': 'str',
+    assert to_dict(config.value.get()) == {'positional': 'str',
                                    'positional_int': 1,
                                    'str': None,
                                    'int': None,

tests/test_help.py

@@ -6,12 +6,14 @@ from argparse import RawDescriptionHelpFormatter
 
 from tiramisu_cmdline_parser import TiramisuCmdlineParser
 from tiramisu import IntOption, StrOption, BoolOption, ChoiceOption, \
-                     SymLinkOption, OptionDescription, Config
+                     OptionDescription, Config
 try:
     from tiramisu_api import Config as JsonConfig
-    params = ['tiramisu', 'tiramisu-json']
+    #params = ['tiramisu', 'tiramisu-json']
+    params = ['tiramisu']
 except:
     params = ['tiramisu']
+from .utils import TestHelpFormatter
 
 
 
@@ -43,15 +45,13 @@ def json(request):
 def test_help(json):
     output = """usage: prog.py [-h] {str,list,int,none}
 
-optional arguments:
+options:
   -h, --help           show this help message and exit
 
 od:
-  od
-
   {str,list,int,none}  choice the sub argument
 """
-    parser = TiramisuCmdlineParser(get_config(json), 'prog.py')
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stdout(f):
         parser.print_help()
@@ -61,17 +61,15 @@ od:
 def test_help_epilog(json):
     output = """usage: prog.py [-h] {str,list,int,none}
 
-optional arguments:
+options:
   -h, --help           show this help message and exit
 
 od:
-  od
-
   {str,list,int,none}  choice the sub argument
 
 two line
 """
-    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', epilog="\ntwo\nline")
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', epilog="\ntwo\nline", formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stdout(f):
         parser.print_help()
@@ -81,12 +79,10 @@ two line
 def test_help_epilog_raw(json):
     output = """usage: prog.py [-h] {str,list,int,none}
 
-optional arguments:
+options:
   -h, --help           show this help message and exit
 
 od:
-  od
-
   {str,list,int,none}  choice the sub argument
 
 two

tests/test_leadership.py

@@ -5,13 +5,16 @@ import pytest
 
 from tiramisu_cmdline_parser import TiramisuCmdlineParser
 from tiramisu import IntOption, StrOption, BoolOption, ChoiceOption, \
-                     SymLinkOption, OptionDescription, Leadership, Config, submulti
+                     OptionDescription, Leadership, Config, submulti
 try:
     from tiramisu_api import Config as JsonConfig
-    params = ['tiramisu', 'tiramisu-json']
+#    params = ['tiramisu', 'tiramisu-json']
+    params = ['tiramisu']
 except:
     params = ['tiramisu']
 
+from .utils import TestHelpFormatter, to_dict
+
 
 def get_config(json, with_mandatory=False):
     leader = StrOption('leader', "Leader var", ['192.168.0.1'], multi=True)
@@ -41,23 +44,13 @@ def json(request):
 
 
 def test_leadership_help(json):
-    output = """usage: prog.py [-h] [--leader.leader [LEADER [LEADER ...]]]
+    output = """usage: prog.py [-h] [--leader.leader [LEADER ...]] [--leader.pop-leader INDEX] [--leader.follower INDEX [FOLLOWER]] --leader.follower_submulti INDEX [FOLLOWER_SUBMULTI ...] [--leader.follower_integer INDEX [FOLLOWER_INTEGER]] [--leader.follower_boolean INDEX] [--leader.no-follower_boolean INDEX] [--leader.follower_choice INDEX [{opt1,opt2}]] --leader.follower_mandatory INDEX FOLLOWER_MANDATORY
-               [--leader.pop-leader INDEX]
-               [--leader.follower INDEX [FOLLOWER]] --leader.follower_submulti
-               INDEX [FOLLOWER_SUBMULTI ...]
-               [--leader.follower_integer INDEX [FOLLOWER_INTEGER]]
-               [--leader.follower_boolean INDEX]
-               [--leader.no-follower_boolean INDEX]
-               [--leader.follower_choice INDEX [{opt1,opt2}]]
-               --leader.follower_mandatory INDEX FOLLOWER_MANDATORY
 
-optional arguments:
+options:
   -h, --help            show this help message and exit
 
 leader:
-  leader
+  --leader.leader [LEADER ...]
-
-  --leader.leader [LEADER [LEADER ...]]
                         Leader var
   --leader.pop-leader INDEX
   --leader.follower INDEX [FOLLOWER]
@@ -74,7 +67,7 @@ leader:
   --leader.follower_mandatory INDEX FOLLOWER_MANDATORY
                         Follower mandatory
 """
-    parser = TiramisuCmdlineParser(get_config(json, with_mandatory=True), 'prog.py')
+    parser = TiramisuCmdlineParser(get_config(json, with_mandatory=True), 'prog.py', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stdout(f):
         parser.print_help()
@@ -92,7 +85,7 @@ def test_leadership_modif_leader(json):
     config = get_config(json)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['--leader.leader', '192.168.1.1'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_leadership_modif_follower(json):
@@ -106,23 +99,16 @@ def test_leadership_modif_follower(json):
     config = get_config(json)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['--leader.follower', '0', '255.255.255.0'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_leadership_modif_follower_not_submulti(json):
-    output = """usage: prog.py [-h] [--leader.leader [LEADER [LEADER ...]]]
+    output = """usage: prog.py [-h] [--leader.leader [LEADER ...]] [--leader.pop-leader INDEX] [--leader.follower INDEX [FOLLOWER]] [--leader.follower_submulti INDEX [FOLLOWER_SUBMULTI ...]] [--leader.follower_integer INDEX [FOLLOWER_INTEGER]] [--leader.follower_boolean INDEX] [--leader.no-follower_boolean INDEX] [--leader.follower_choice INDEX [{opt1,opt2}]]
-               [--leader.pop-leader INDEX]
-               [--leader.follower INDEX [FOLLOWER]]
-               [--leader.follower_submulti INDEX [FOLLOWER_SUBMULTI ...]]
-               [--leader.follower_integer INDEX [FOLLOWER_INTEGER]]
-               [--leader.follower_boolean INDEX]
-               [--leader.no-follower_boolean INDEX]
-               [--leader.follower_choice INDEX [{opt1,opt2}]]
 prog.py: error: unrecognized arguments: 255.255.255.0
 """
 
     config = get_config(json)
-    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser = TiramisuCmdlineParser(config, 'prog.py', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -145,7 +131,7 @@ def test_leadership_modif_follower_submulti(json):
     config = get_config(json)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['--leader.follower_submulti', '0', '255.255.255.0'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_leadership_modif_follower_submulti_multi(json):
@@ -159,7 +145,7 @@ def test_leadership_modif_follower_submulti_multi(json):
     config = get_config(json)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['--leader.follower_submulti', '0', '255.255.255.0', '255.255.255.128'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_leadership_modif_follower_bool_true(json):
@@ -173,7 +159,7 @@ def test_leadership_modif_follower_bool_true(json):
     config = get_config(json)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['--leader.follower_boolean', '0'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_leadership_modif_follower_bool_false(json):
@@ -187,7 +173,7 @@ def test_leadership_modif_follower_bool_false(json):
     config = get_config(json)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['--leader.no-follower_boolean', '0'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_leadership_modif_follower_bool_true_fullname(json):
@@ -201,7 +187,7 @@ def test_leadership_modif_follower_bool_true_fullname(json):
     config = get_config(json)
     parser = TiramisuCmdlineParser(config, 'prog.py', fullpath=False)
     parser.parse_args(['--follower_boolean', '0'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_leadership_modif_follower_bool_false_fullname(json):
@@ -215,7 +201,7 @@ def test_leadership_modif_follower_bool_false_fullname(json):
     config = get_config(json)
     parser = TiramisuCmdlineParser(config, 'prog.py', fullpath=False)
     parser.parse_args(['--no-follower_boolean', '0'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_leadership_modif_follower_choice(json):
@@ -229,22 +215,15 @@ def test_leadership_modif_follower_choice(json):
     config = get_config(json)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['--leader.follower_choice', '0', 'opt1'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_leadership_modif_follower_choice_unknown(json):
-    output = """usage: prog.py [-h] [--leader.leader [LEADER [LEADER ...]]]
+    output = """usage: prog.py [-h] [--leader.leader [LEADER ...]] [--leader.pop-leader INDEX] [--leader.follower INDEX [FOLLOWER]] [--leader.follower_submulti INDEX [FOLLOWER_SUBMULTI ...]] [--leader.follower_integer INDEX [FOLLOWER_INTEGER]] [--leader.follower_boolean INDEX] [--leader.no-follower_boolean INDEX] [--leader.follower_choice INDEX [{opt1,opt2}]]
-               [--leader.pop-leader INDEX]
-               [--leader.follower INDEX [FOLLOWER]]
-               [--leader.follower_submulti INDEX [FOLLOWER_SUBMULTI ...]]
-               [--leader.follower_integer INDEX [FOLLOWER_INTEGER]]
-               [--leader.follower_boolean INDEX]
-               [--leader.no-follower_boolean INDEX]
-               [--leader.follower_choice INDEX [{opt1,opt2}]]
 prog.py: error: argument --leader.follower_choice: invalid choice: 'opt_unknown' (choose from 'opt1', 'opt2')
 """
     config = get_config(json)
-    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser = TiramisuCmdlineParser(config, 'prog.py', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -257,19 +236,12 @@ prog.py: error: argument --leader.follower_choice: invalid choice: 'opt_unknown'
 
 
 def test_leadership_modif_follower_not_number(json):
-    output = """usage: prog.py [-h] [--leader.leader [LEADER [LEADER ...]]]
+    output = """usage: prog.py [-h] [--leader.leader [LEADER ...]] [--leader.pop-leader INDEX] [--leader.follower INDEX [FOLLOWER]] [--leader.follower_submulti INDEX [FOLLOWER_SUBMULTI ...]] [--leader.follower_integer INDEX [FOLLOWER_INTEGER]] [--leader.follower_boolean INDEX] [--leader.no-follower_boolean INDEX] [--leader.follower_choice INDEX [{opt1,opt2}]]
-               [--leader.pop-leader INDEX]
-               [--leader.follower INDEX [FOLLOWER]]
-               [--leader.follower_submulti INDEX [FOLLOWER_SUBMULTI ...]]
-               [--leader.follower_integer INDEX [FOLLOWER_INTEGER]]
-               [--leader.follower_boolean INDEX]
-               [--leader.no-follower_boolean INDEX]
-               [--leader.follower_choice INDEX [{opt1,opt2}]]
 prog.py: error: index must be a number, not a
 """
 
     config = get_config(json)
-    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser = TiramisuCmdlineParser(config, 'prog.py', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -294,7 +266,7 @@ def test_leadership_modif_multi(json):
     parser.parse_args(['--leader.leader', '192.168.1.1', '10.253.10.1', '192.168.253.1',
                        '--leader.follower', '0', '255.255.255.128',
                        '--leader.follower', '2', '255.255.255.0'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_leadership_modif_multi_reduce(json):
@@ -311,7 +283,7 @@ def test_leadership_modif_multi_reduce(json):
                        '--leader.follower', '0', '255.255.255.128',
                        '--leader.follower', '2', '255.255.255.0',
                        '--leader.pop-leader', '1'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_leadership_modif_mandatory(json):
@@ -322,22 +294,11 @@ def test_leadership_modif_mandatory(json):
               'leader.follower_choice': [None],
               'leader.follower_integer': [None],
               'leader.follower_submulti': [['255.255.255.128']]}
-    output2 = """usage: prog.py --leader.leader "192.168.1.1" [-h]
+    output2 = """usage: prog.py --leader.leader "192.168.1.1" [-h] [--leader.leader [LEADER ...]] [--leader.pop-leader INDEX] [--leader.follower INDEX [FOLLOWER]] --leader.follower_submulti INDEX [FOLLOWER_SUBMULTI ...] [--leader.follower_integer INDEX [FOLLOWER_INTEGER]] [--leader.follower_boolean INDEX] [--leader.no-follower_boolean INDEX] [--leader.follower_choice INDEX [{opt1,opt2}]] --leader.follower_mandatory INDEX FOLLOWER_MANDATORY
-                                             [--leader.leader [LEADER [LEADER ...]]]
-                                             [--leader.pop-leader INDEX]
-                                             [--leader.follower INDEX [FOLLOWER]]
-                                             --leader.follower_submulti INDEX
-                                             [FOLLOWER_SUBMULTI ...]
-                                             [--leader.follower_integer INDEX [FOLLOWER_INTEGER]]
-                                             [--leader.follower_boolean INDEX]
-                                             [--leader.no-follower_boolean INDEX]
-                                             [--leader.follower_choice INDEX [{opt1,opt2}]]
-                                             --leader.follower_mandatory INDEX
-                                             FOLLOWER_MANDATORY
 prog.py: error: the following arguments are required: --leader.follower_submulti"""
 
     config = get_config(json, with_mandatory=True)
-    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser = TiramisuCmdlineParser(config, 'prog.py', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -360,7 +321,7 @@ prog.py: error: the following arguments are required: --leader.follower_submulti
     parser.parse_args(['--leader.leader', '192.168.1.1',
                        '--leader.follower_submulti', '0', '255.255.255.128',
                        '--leader.follower_mandatory', '0', '255.255.255.128'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_leadership_modif_mandatory_remove(json):
@@ -371,20 +332,11 @@ def test_leadership_modif_mandatory_remove(json):
               'leader.follower_choice': [None],
               'leader.follower_integer': [None],
               'leader.follower_submulti': [['255.255.255.128']]}
-    output2 = """usage: prog.py --leader.leader "192.168.1.1" [-h] [--leader.pop-leader INDEX]
+    output2 = """usage: prog.py --leader.leader "192.168.1.1" [-h] [--leader.pop-leader INDEX] [--leader.follower INDEX [FOLLOWER]] --leader.follower_submulti INDEX [FOLLOWER_SUBMULTI ...] [--leader.follower_integer INDEX [FOLLOWER_INTEGER]] [--leader.follower_boolean INDEX] [--leader.no-follower_boolean INDEX] [--leader.follower_choice INDEX [{opt1,opt2}]] --leader.follower_mandatory INDEX FOLLOWER_MANDATORY
-                                             [--leader.follower INDEX [FOLLOWER]]
-                                             --leader.follower_submulti INDEX
-                                             [FOLLOWER_SUBMULTI ...]
-                                             [--leader.follower_integer INDEX [FOLLOWER_INTEGER]]
-                                             [--leader.follower_boolean INDEX]
-                                             [--leader.no-follower_boolean INDEX]
-                                             [--leader.follower_choice INDEX [{opt1,opt2}]]
-                                             --leader.follower_mandatory INDEX
-                                             FOLLOWER_MANDATORY
 prog.py: error: the following arguments are required: --leader.follower_submulti"""
 
     config = get_config(json, with_mandatory=True)
-    parser = TiramisuCmdlineParser(config, 'prog.py', display_modified_value=False)
+    parser = TiramisuCmdlineParser(config, 'prog.py', display_modified_value=False, formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -407,7 +359,7 @@ prog.py: error: the following arguments are required: --leader.follower_submulti
     parser.parse_args(['--leader.leader', '192.168.1.1',
                        '--leader.follower_submulti', '0', '255.255.255.128',
                        '--leader.follower_mandatory', '0', '255.255.255.128'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_leadership_modif_mandatory_unvalidate(json):
@@ -421,4 +373,4 @@ def test_leadership_modif_mandatory_unvalidate(json):
     config = get_config(json, with_mandatory=True)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['--leader.leader', '192.168.1.1'], valid_mandatory=False)
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output

tests/test_optiondescription.py

@@ -8,9 +8,11 @@ from tiramisu import IntOption, StrOption, BoolOption, ChoiceOption, \
                      SymLinkOption, OptionDescription, Config
 try:
     from tiramisu_api import Config as JsonConfig
-    params = ['tiramisu', 'tiramisu-json']
+    #params = ['tiramisu', 'tiramisu-json']
+    params = ['tiramisu']
 except:
     params = ['tiramisu']
+from .utils import TestHelpFormatter
 
 
 def get_config(json, has_tree=False, default_verbosity=False, add_long=False, add_store_false=False, empty_optiondescription=False):
@@ -69,11 +71,9 @@ def json(request):
 
 
 def test_optiondescription_help(json):
-    output = """usage: prog.py [-h] [-v] [-nv] --od2.subtree.str STR --od2.before BEFORE
+    output = """usage: prog.py [-h] [-v] [-nv] --od2.subtree.str STR --od2.before BEFORE --od2.after AFTER {str,list,int,none}
-               --od2.after AFTER
-               {str,list,int,none}
 
-optional arguments:
+options:
   -h, --help            show this help message and exit
 
 od1:
@@ -84,7 +84,7 @@ od1.od0:
 
   {str,list,int,none}   choice the sub argument
   -v, --od1.od0.verbosity
-                        increase output verbosity
+                        increase output verbosity (default: False)
   -nv, --od1.od0.no-verbosity
 
 od2:
@@ -97,7 +97,7 @@ od2.subtree:
   --od2.subtree.str STR
                         string option 2
 """
-    parser = TiramisuCmdlineParser(get_config(json), 'prog.py')
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stdout(f):
         parser.print_help()
@@ -105,11 +105,9 @@ od2.subtree:
 
 
 def test_optiondescription_help_remove_empty_od(json):
-    output = """usage: prog.py [-h] [-v] [-nv] --od2.subtree.str STR --od2.before BEFORE
+    output = """usage: prog.py [-h] [-v] [-nv] --od2.subtree.str STR --od2.before BEFORE --od2.after AFTER {str,list,int,none}
-               --od2.after AFTER
-               {str,list,int,none}
 
-optional arguments:
+options:
   -h, --help            show this help message and exit
 
 od1.od0:
@@ -117,7 +115,7 @@ od1.od0:
 
   {str,list,int,none}   choice the sub argument
   -v, --od1.od0.verbosity
-                        increase output verbosity
+                        increase output verbosity (default: False)
   -nv, --od1.od0.no-verbosity
 
 od2:
@@ -130,7 +128,7 @@ od2.subtree:
   --od2.subtree.str STR
                         string option 2
 """
-    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', remove_empty_od=True)
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', remove_empty_od=True, formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stdout(f):
         parser.print_help()
@@ -138,11 +136,9 @@ od2.subtree:
 
 
 def test_optiondescription_help_remove_empty_description_od(json):
-    output = """usage: prog.py [-h] [-v] [-nv] --od2.subtree.str STR --od2.before BEFORE
+    output = """usage: prog.py [-h] [-v] [-nv] --od2.subtree.str STR --od2.before BEFORE --od2.after AFTER {str,list,int,none}
-               --od2.after AFTER
-               {str,list,int,none}
 
-optional arguments:
+options:
   -h, --help            show this help message and exit
 
 od1.od0:
@@ -150,7 +146,7 @@ od1.od0:
 
   {str,list,int,none}   choice the sub argument
   -v, --od1.od0.verbosity
-                        increase output verbosity
+                        increase output verbosity (default: False)
   -nv, --od1.od0.no-verbosity
 
 od2:
@@ -163,7 +159,7 @@ od2.subtree:
   --od2.subtree.str STR
                         string option 2
 """
-    parser = TiramisuCmdlineParser(get_config(json, empty_optiondescription=True), 'prog.py')
+    parser = TiramisuCmdlineParser(get_config(json, empty_optiondescription=True), 'prog.py', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stdout(f):
         parser.print_help()
@@ -171,10 +167,9 @@ od2.subtree:
 
 
 def test_optiondescription_help_subtree(json):
-    output = """usage: prog.py [-h] --od2.subtree.str STR --od2.before BEFORE --od2.after
+    output = """usage: prog.py [-h] --od2.subtree.str STR --od2.before BEFORE --od2.after AFTER
-               AFTER
 
-optional arguments:
+options:
   -h, --help            show this help message and exit
   --od2.before BEFORE   Before
   --od2.after AFTER     After
@@ -186,7 +181,7 @@ od2.subtree:
                         string option 2
 """
     config = get_config(json)
-    parser = TiramisuCmdlineParser(config, 'prog.py', root='od2')
+    parser = TiramisuCmdlineParser(config, 'prog.py', root='od2', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stdout(f):
         parser.print_help()

tests/test_readme.py

@@ -5,12 +5,15 @@ import pytest
 
 from tiramisu_cmdline_parser import TiramisuCmdlineParser
 from tiramisu import IntOption, StrOption, BoolOption, ChoiceOption, \
-                     SymLinkOption, OptionDescription, Config
+                     SymLinkOption, OptionDescription, Config, calc_value, \
+                     Calculation, ParamValue, ParamOption, Params
 try:
     from tiramisu_api import Config as JsonConfig
-    params = ['tiramisu', 'tiramisu-json']
+    #params = ['tiramisu', 'tiramisu-json']
+    params = ['tiramisu']
 except:
     params = ['tiramisu']
+from .utils import TestHelpFormatter, to_dict
 
 
 def get_config(json, has_tree=False, default_verbosity=False, add_long=False, add_store_false=False):
@@ -25,26 +28,35 @@ def get_config(json, has_tree=False, default_verbosity=False, add_long=False, ad
     short_booloption = SymLinkOption('v', booloption)
     str_ = StrOption('str',
                      'string option',
-                     properties=('mandatory',),
+                     properties=('mandatory',
-                     requires=[{'option': choiceoption,
+                                 Calculation(calc_value,
-                                'expected': 'str',
+                                             Params(ParamValue('disabled'),
-                                'action': 'disabled',
+                                                    kwargs={'condition': ParamOption(choiceoption),
-                                'inverse': True}])
+                                                            'reverse_condition': ParamValue(True),
+                                                            'expected': ParamValue('str')})),
+                                 ),
+                     )
     list_ = StrOption('list',
                       'list string option',
                       multi=True,
-                      properties=('mandatory',),
+                      properties=('mandatory',
-                      requires=[{'option': choiceoption,
+                                  Calculation(calc_value,
-                                 'expected': 'list',
+                                              Params(ParamValue('disabled'),
-                                 'action': 'disabled',
+                                                     kwargs={'condition': ParamOption(choiceoption),
-                                 'inverse': True}])
+                                                             'reverse_condition': ParamValue(True),
+                                                             'expected': ParamValue('list')})),
+                                  ),
+                      )
     int_ = IntOption('int',
                      'int option',
-                     properties=('mandatory',),
+                      properties=('mandatory',
-                     requires=[{'option': choiceoption,
+                                  Calculation(calc_value,
-                                'expected': 'int',
+                                              Params(ParamValue('disabled'),
-                                'action': 'disabled',
+                                                     kwargs={'condition': ParamOption(choiceoption),
-                                'inverse': True}])
+                                                             'reverse_condition': ParamValue(True),
+                                                             'expected': ParamValue('int')})),
+                                  ),
+                     )
 
     root = OptionDescription('root',
                              'root',
@@ -82,12 +94,12 @@ def test_readme_help(json):
 positional arguments:
   {str,list,int,none}  choice the sub argument
 
-optional arguments:
+options:
   -h, --help           show this help message and exit
-  -v, --verbosity      increase output verbosity
+  -v, --verbosity      increase output verbosity (default: False)
   -nv, --no-verbosity
 """
-    parser = TiramisuCmdlineParser(get_config(json), 'prog.py')
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stdout(f):
         parser.print_help()
@@ -97,17 +109,15 @@ optional arguments:
 def test_readme_help_tree(json):
     output = """usage: prog.py [-h] [-v] [-nv] {str,list,int,none}
 
-optional arguments:
+options:
   -h, --help            show this help message and exit
 
 root:
-  root
-
   {str,list,int,none}   choice the sub argument
-  -v, --root.verbosity  increase output verbosity
+  -v, --root.verbosity  increase output verbosity (default: False)
   -nv, --root.no-verbosity
 """
-    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py')
+    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stdout(f):
         parser.print_help()
@@ -117,17 +127,15 @@ root:
 def test_readme_help_tree_flatten(json):
     output = """usage: prog.py [-h] [-v] [-nv] {str,list,int,none}
 
-optional arguments:
+options:
   -h, --help           show this help message and exit
 
 root:
-  root
-
   {str,list,int,none}  choice the sub argument
-  -v, --verbosity      increase output verbosity
+  -v, --verbosity      increase output verbosity (default: False)
   -nv, --no-verbosity
 """
-    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', fullpath=False)
+    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', fullpath=False, formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stdout(f):
         parser.print_help()
@@ -140,13 +148,13 @@ def test_readme_help_modif_positional(json):
 positional arguments:
   {str,list,int,none}  choice the sub argument
 
-optional arguments:
+options:
   -h, --help           show this help message and exit
-  -v, --verbosity      increase output verbosity
+  -v, --verbosity      increase output verbosity (default: False)
   -nv, --no-verbosity
   --str STR            string option
 """
-    parser = TiramisuCmdlineParser(get_config(json), 'prog.py')
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stdout(f):
         try:
@@ -161,13 +169,13 @@ optional arguments:
 def test_readme_help_modif_positional_remove(json):
     output = """usage: prog.py "str" [-h] [-v] [-nv] --str STR
 
-optional arguments:
+options:
   -h, --help           show this help message and exit
-  -v, --verbosity      increase output verbosity
+  -v, --verbosity      increase output verbosity (default: False)
   -nv, --no-verbosity
   --str STR            string option
 """
-    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', display_modified_value=False)
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', display_modified_value=False, formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stdout(f):
         try:
@@ -180,19 +188,18 @@ optional arguments:
 
 
 def test_readme_help_modif(json):
-    output = """usage: prog.py "str" --str "toto" [-h] [-v] [-nv] --str STR
+    output = """usage: prog.py "str" --str "toto" [-h] [-v] [-nv] --str STR {str,list,int,none}
-                                  {str,list,int,none}
 
 positional arguments:
   {str,list,int,none}  choice the sub argument
 
-optional arguments:
+options:
   -h, --help           show this help message and exit
-  -v, --verbosity      increase output verbosity
+  -v, --verbosity      increase output verbosity (default: False)
   -nv, --no-verbosity
   --str STR            string option
 """
-    parser = TiramisuCmdlineParser(get_config(json), 'prog.py')
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stdout(f):
         try:
@@ -207,12 +214,12 @@ optional arguments:
 def test_readme_help_modif_remove(json):
     output = """usage: prog.py "str" --str "toto" [-h] [-v] [-nv]
 
-optional arguments:
+options:
   -h, --help           show this help message and exit
-  -v, --verbosity      increase output verbosity
+  -v, --verbosity      increase output verbosity (default: False)
   -nv, --no-verbosity
 """
-    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', display_modified_value=False)
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', display_modified_value=False, formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stdout(f):
         try:
@@ -230,13 +237,13 @@ def test_readme_help_modif_short(json):
 positional arguments:
   {str,list,int,none}  choice the sub argument
 
-optional arguments:
+options:
   -h, --help           show this help message and exit
-  -v, --verbosity      increase output verbosity
+  -v, --verbosity      increase output verbosity (default: False)
   -nv, --no-verbosity
   --str STR            string option
 """
-    parser = TiramisuCmdlineParser(get_config(json), 'prog.py')
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stdout(f):
         try:
@@ -252,12 +259,12 @@ def test_readme_help_modif_short_remove(json):
 	# FIXME -v -nv ?? pas de description
     output = """usage: prog.py "str" -v [-h] [-nv] --str STR
 
-optional arguments:
+options:
   -h, --help           show this help message and exit
-  -nv, --no-verbosity  increase output verbosity
+  -nv, --no-verbosity  increase output verbosity (default: False)
   --str STR            string option
 """
-    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', display_modified_value=False)
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', display_modified_value=False, formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stdout(f):
         try:
@@ -275,13 +282,13 @@ def test_readme_help_modif_short_no1(json):
 positional arguments:
   {str,list,int,none}  choice the sub argument
 
-optional arguments:
+options:
   -h, --help           show this help message and exit
-  -v, --verbosity      increase output verbosity
+  -v, --verbosity      increase output verbosity (default: False)
   -nv, --no-verbosity
   --str STR            string option
 """
-    parser = TiramisuCmdlineParser(get_config(json), 'prog.py')
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stdout(f):
         try:
@@ -296,12 +303,12 @@ optional arguments:
 def test_readme_help_modif_short_no_remove(json):
     output = """usage: prog.py "str" -v [-h] [-v] --str STR
 
-optional arguments:
+options:
   -h, --help       show this help message and exit
-  -v, --verbosity  increase output verbosity
+  -v, --verbosity  increase output verbosity (default: False)
   --str STR        string option
 """
-    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', display_modified_value=False)
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', display_modified_value=False, formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stdout(f):
         try:
@@ -317,7 +324,7 @@ def test_readme_positional_mandatory(json):
     output = """usage: prog.py [-h] [-v] [-nv] {str,list,int,none}
 prog.py: error: the following arguments are required: cmd
 """
-    parser = TiramisuCmdlineParser(get_config(json), 'prog.py')
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -333,7 +340,7 @@ def test_readme_positional_mandatory_tree(json):
     output = """usage: prog.py [-h] [-v] [-nv] {str,list,int,none}
 prog.py: error: the following arguments are required: root.cmd
 """
-    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py')
+    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -349,7 +356,7 @@ def test_readme_positional_mandatory_tree_flatten(json):
     output = """usage: prog.py [-h] [-v] [-nv] {str,list,int,none}
 prog.py: error: the following arguments are required: cmd
 """
-    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', fullpath=False)
+    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', fullpath=False, formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -365,7 +372,7 @@ def test_readme_mandatory(json):
     output = """usage: prog.py "str" [-h] [-v] [-nv] --str STR {str,list,int,none}
 prog.py: error: the following arguments are required: --str
 """
-    parser = TiramisuCmdlineParser(get_config(json), 'prog.py')
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -381,7 +388,7 @@ def test_readme_mandatory_remove(json):
     output = """usage: prog.py "str" [-h] [-v] [-nv] --str STR
 prog.py: error: the following arguments are required: --str
 """
-    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', display_modified_value=False)
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', display_modified_value=False, formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -397,7 +404,7 @@ def test_readme_mandatory_tree(json):
     output = """usage: prog.py "str" [-h] [-v] [-nv] --root.str STR {str,list,int,none}
 prog.py: error: the following arguments are required: --root.str
 """
-    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py')
+    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -413,7 +420,7 @@ def test_readme_mandatory_tree_remove(json):
     output = """usage: prog.py "str" [-h] [-v] [-nv] --root.str STR
 prog.py: error: the following arguments are required: --root.str
 """
-    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', display_modified_value=False)
+    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', display_modified_value=False, formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -429,7 +436,7 @@ def test_readme_mandatory_tree_flatten(json):
     output = """usage: prog.py "str" [-h] [-v] [-nv] --str STR {str,list,int,none}
 prog.py: error: the following arguments are required: --str
 """
-    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', fullpath=False)
+    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', fullpath=False, formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -445,7 +452,7 @@ def test_readme_mandatory_tree_flatten_remove(json):
     output = """usage: prog.py "str" [-h] [-v] [-nv] --str STR
 prog.py: error: the following arguments are required: --str
 """
-    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', fullpath=False, display_modified_value=False)
+    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', fullpath=False, display_modified_value=False, formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -461,7 +468,7 @@ def test_readme_cross(json):
     output = """usage: prog.py "none" [-h] [-v] [-nv] {str,list,int,none}
 prog.py: error: unrecognized arguments: --int
 """
-    parser = TiramisuCmdlineParser(get_config(json), 'prog.py')
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -477,7 +484,7 @@ def test_readme_cross_remove(json):
     output = """usage: prog.py "none" [-h] [-v] [-nv]
 prog.py: error: unrecognized arguments: --int
 """
-    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', display_modified_value=False)
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', display_modified_value=False, formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -493,7 +500,7 @@ def test_readme_cross_tree(json):
     output = """usage: prog.py "none" [-h] [-v] [-nv] {str,list,int,none}
 prog.py: error: unrecognized arguments: --root.int
 """
-    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py')
+    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -509,7 +516,7 @@ def test_readme_cross_tree_remove(json):
     output = """usage: prog.py "none" [-h] [-v] [-nv]
 prog.py: error: unrecognized arguments: --root.int
 """
-    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', display_modified_value=False)
+    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', display_modified_value=False, formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -525,7 +532,7 @@ def test_readme_cross_tree_flatten(json):
     output = """usage: prog.py "none" [-h] [-v] [-nv] {str,list,int,none}
 prog.py: error: unrecognized arguments: --int
 """
-    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', fullpath=False)
+    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', fullpath=False, formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -541,7 +548,7 @@ def test_readme_cross_tree_flatten_remove(json):
     output = """usage: prog.py "none" [-h] [-v] [-nv]
 prog.py: error: unrecognized arguments: --int
 """
-    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', fullpath=False, display_modified_value=False)
+    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', fullpath=False, display_modified_value=False, formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -557,7 +564,7 @@ def test_readme_unknown(json):
     output = """usage: prog.py [-h] [-v] [-nv] {str,list,int,none}
 prog.py: error: argument root.cmd: invalid choice: 'unknown' (choose from 'str', 'list', 'int', 'none')
 """
-    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', fullpath=False)
+    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', fullpath=False, formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:
@@ -577,7 +584,7 @@ def test_readme_int(json):
     config = get_config(json)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['int', '--int', '3'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_int_tree(json):
@@ -588,7 +595,7 @@ def test_readme_int_tree(json):
     config = get_config(json, True)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['int', '--root.int', '3'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_int_tree_flatten(json):
@@ -599,7 +606,7 @@ def test_readme_int_tree_flatten(json):
     config = get_config(json, True)
     parser = TiramisuCmdlineParser(config, 'prog.py', fullpath=False)
     parser.parse_args(['int', '--int', '3'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_int_verbosity(json):
@@ -610,7 +617,7 @@ def test_readme_int_verbosity(json):
     config = get_config(json)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['int', '--int', '3', '--verbosity'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_int_verbosity_tree(json):
@@ -621,7 +628,7 @@ def test_readme_int_verbosity_tree(json):
     config = get_config(json, True)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['int', '--root.int', '3', '--root.verbosity'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_int_verbosity_tree_flatten(json):
@@ -632,7 +639,7 @@ def test_readme_int_verbosity_tree_flatten(json):
     config = get_config(json, True)
     parser = TiramisuCmdlineParser(config, 'prog.py', fullpath=False)
     parser.parse_args(['int', '--int', '3', '--verbosity'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_int_verbosity_short(json):
@@ -643,7 +650,7 @@ def test_readme_int_verbosity_short(json):
     config = get_config(json)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['int', '--int', '3', '-v'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_int_verbosity_short_store_false(json):
@@ -658,13 +665,13 @@ def test_readme_int_verbosity_short_store_false(json):
               'int': 3,
               'verbosity': False,
               'v': False}
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
     parser.parse_args(['int', '--int', '3', '-nv'])
     output = {'cmd': 'int',
               'int': 3,
               'verbosity': True,
               'v': True}
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_int_verbosity_short_no(json):
@@ -675,7 +682,7 @@ def test_readme_int_verbosity_short_no(json):
     config = get_config(json)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['int', '--int', '3', '-nv'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_int_verbosity_short_tree(json):
@@ -686,7 +693,7 @@ def test_readme_int_verbosity_short_tree(json):
     config = get_config(json, True)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['int', '--root.int', '3', '-v'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_int_verbosity_short_tree_flatten(json):
@@ -697,7 +704,7 @@ def test_readme_int_verbosity_short_tree_flatten(json):
     config = get_config(json, True)
     parser = TiramisuCmdlineParser(config, 'prog.py', fullpath=False)
     parser.parse_args(['int', '--int', '3', '-v'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_int_verbosity_short_and_not(json):
@@ -708,7 +715,7 @@ def test_readme_int_verbosity_short_and_not(json):
     config = get_config(json)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['int', '--int', '3', '-v', '-nv'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_str(json):
@@ -719,7 +726,7 @@ def test_readme_str(json):
     config = get_config(json)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['str', '--str', 'value'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_str_tree(json):
@@ -730,7 +737,7 @@ def test_readme_str_tree(json):
     config = get_config(json, True)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['str', '--root.str', 'value'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_str_tree_flatten(json):
@@ -741,7 +748,7 @@ def test_readme_str_tree_flatten(json):
     config = get_config(json, True)
     parser = TiramisuCmdlineParser(config, 'prog.py', fullpath=False)
     parser.parse_args(['str', '--str', 'value'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_str_int(json):
@@ -752,7 +759,7 @@ def test_readme_str_int(json):
     config = get_config(json)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['str', '--str', '3'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_str_int_tree(json):
@@ -763,7 +770,7 @@ def test_readme_str_int_tree(json):
     config = get_config(json, True)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['str', '--root.str', '3'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_str_int_tree_flatten(json):
@@ -774,7 +781,7 @@ def test_readme_str_int_tree_flatten(json):
     config = get_config(json, True)
     parser = TiramisuCmdlineParser(config, 'prog.py', fullpath=False)
     parser.parse_args(['str', '--str', '3'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_list_single(json):
@@ -785,7 +792,7 @@ def test_readme_list_single(json):
     config = get_config(json)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['list', '--list', 'a'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_list(json):
@@ -796,7 +803,7 @@ def test_readme_list(json):
     config = get_config(json)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['list', '--list', 'a', 'b', 'c'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_list_tree(json):
@@ -807,7 +814,7 @@ def test_readme_list_tree(json):
     config = get_config(json, True)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['list', '--root.list', 'a', 'b', 'c'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_list_tree_flatten(json):
@@ -818,7 +825,7 @@ def test_readme_list_tree_flatten(json):
     config = get_config(json, True)
     parser = TiramisuCmdlineParser(config, 'prog.py', fullpath=False)
     parser.parse_args(['list', '--list', 'a', 'b', 'c'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_list_uniq(json):
@@ -829,7 +836,7 @@ def test_readme_list_uniq(json):
     config = get_config(json)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['list', '--list', 'a'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_list_uniq_tree(json):
@@ -840,7 +847,7 @@ def test_readme_list_uniq_tree(json):
     config = get_config(json, True)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['list', '--root.list', 'a'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_list_uniq_tree_flatten(json):
@@ -851,7 +858,7 @@ def test_readme_list_uniq_tree_flatten(json):
     config = get_config(json, True)
     parser = TiramisuCmdlineParser(config, 'prog.py', fullpath=False)
     parser.parse_args(['list', '--list', 'a'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_longargument(json):
@@ -862,7 +869,7 @@ def test_readme_longargument(json):
     config = get_config(json, add_long=True)
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['list', '--list', 'a', '--v'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_readme_unknown_key(json):
@@ -872,7 +879,7 @@ prog.py: error: unrecognized arguments: --unknown
     output2 = """usage: prog.py [-h] [-v] [-nv] {str,list,int,none}
 prog.py: error: unrecognized arguments: --root.unknown
 """
-    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', fullpath=False)
+    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', fullpath=False, formatter_class=TestHelpFormatter)
     f = StringIO()
     with redirect_stderr(f):
         try:

tests/test_shortarg.py

@@ -8,10 +8,13 @@ from tiramisu import IntOption, StrOption, BoolOption, ChoiceOption, \
                      SymLinkOption, OptionDescription, Config
 try:
     from tiramisu_api import Config as JsonConfig
-    params = ['tiramisu', 'tiramisu-json']
+    params = ['tiramisu']
+    #params = ['tiramisu', 'tiramisu-json']
 except:
     params = ['tiramisu']
 
+from .utils import to_dict
+
 
 @pytest.fixture(params=params)
 def json(request):
@@ -38,19 +41,19 @@ def test_short(json):
     config = get_config()
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args([])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
     #
     output = {'list': 'a', 'l': 'a'}
     config = get_config()
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['--list', 'a'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
     #
     output = {'list': 'a', 'l': 'a'}
     config = get_config()
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['-l', 'a'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
     #
     assert config.option('list').value.get() == config.option('l').value.get()
     assert config.option('list').owner.get() == config.option('l').owner.get()
@@ -93,13 +96,13 @@ prog.py: error: the following arguments are required: --list
     config = get_config()
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['--list', 'a'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
     #
     output = {'list': 'a', 'l': 'a'}
     config = get_config()
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['-l', 'a'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_short_multi(json):
@@ -123,31 +126,31 @@ def test_short_multi(json):
     config = get_config()
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args([])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
     #
     output = {'list': ['a'], 'l': ['a']}
     config = get_config()
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['--list', 'a'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
     #
     output = {'list': ['a', 'b'], 'l': ['a', 'b']}
     config = get_config()
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['--list', 'a', 'b'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
     #
     output = {'list': ['a'], 'l': ['a']}
     config = get_config()
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['-l', 'a'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
     #
     output = {'list': ['a', 'b'], 'l': ['a', 'b']}
     config = get_config()
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['-l', 'a', 'b'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
 
 
 def test_short_multi_mandatory(json):
@@ -187,22 +190,22 @@ prog.py: error: the following arguments are required: --list
     config = get_config()
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['--list', 'a'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
     #
     output = {'list': ['a', 'b'], 'l': ['a', 'b']}
     config = get_config()
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['--list', 'a', 'b'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
     #
     output = {'list': ['a'], 'l': ['a']}
     config = get_config()
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['-l', 'a'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output
     #
     output = {'list': ['a', 'b'], 'l': ['a', 'b']}
     config = get_config()
     parser = TiramisuCmdlineParser(config, 'prog.py')
     parser.parse_args(['-l', 'a', 'b'])
-    assert config.value.dict() == output
+    assert to_dict(config.value.get()) == output

tests/utils.py

@@ -0,0 +1,35 @@
+from argparse import ArgumentDefaultsHelpFormatter
+from tiramisu_cmdline_parser.api import TiramisuHelpFormatter
+
+
+def _leadership_to_dict(dico, ret):
+    leader, *followers = list(dico)
+    ret[leader.path()] = dico[leader]
+    for follower in followers:
+        follower_path = follower.path()
+        ret.setdefault(follower_path, []).append(dico[follower])
+
+
+def _to_dict(dico, ret):
+    for key, value in dico.items():
+        if key.isoptiondescription():
+            if key.isleadership():
+                _leadership_to_dict(value, ret)
+            else:
+                _to_dict(value, ret)
+        else:
+            ret[key.path()] = value
+
+
+def to_dict(dico):
+    ret = {}
+    _to_dict(dico, ret)
+    return ret
+
+
+class TestHelpFormatter(TiramisuHelpFormatter, ArgumentDefaultsHelpFormatter):
+    def __init__(self,
+                 *args,
+                 **kwargs,
+                 ):
+        return super().__init__(*args, **kwargs, width=5000)

tiramisu_cmdline_parser/api.py

@@ -13,18 +13,17 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 from typing import Union, List, Dict, Tuple, Optional, Any
-from argparse import ArgumentParser, Namespace, SUPPRESS, _HelpAction, HelpFormatter
+from argparse import ArgumentParser, Namespace, SUPPRESS, _HelpAction, HelpFormatter, ArgumentDefaultsHelpFormatter
 from copy import copy
 from gettext import gettext as _
 
-try:
+#try:
-    from tiramisu import Config
+from tiramisu import Config
-    from tiramisu.error import PropertiesOptionError, RequirementError, LeadershipError
+from tiramisu.error import PropertiesOptionError, LeadershipError
-except ImportError:
+#except ImportError:
-    Config = None
+#    Config = None
-    from tiramisu_api.error import PropertiesOptionError
+#    from tiramisu_api.error import PropertiesOptionError
-    RequirementError = PropertiesOptionError
+#    LeadershipError = ValueError
-    LeadershipError = ValueError
 try:
     from tiramisu_api import Config as ConfigJson
     if Config is None:
@@ -33,12 +32,12 @@ except ImportError:
     ConfigJson = Config
 
 
-def get_choice_list(obj, properties, display):
+def get_choice_list(config, properties, display):
     def convert(choice):
         if isinstance(choice, int):
             return str(choice)
         return choice
-    choices = [convert(choice) for choice in obj.value.list()]
+    choices = [convert(choice) for choice in config.value.list()]
     if choices and choices[0] == '':
         del choices[0]
     if display:
@@ -65,18 +64,21 @@ class TiramisuNamespace(Namespace):
             config = self._config
         else:
             config = self._config.option(self._root)
-        for tiramisu_key, tiramisu_value in config.value.dict(fullpath=True).items():
+        self._parse(config.value.get())
-            option = self._config.option(tiramisu_key)
+
-            if not option.option.issymlinkoption():
+    def _parse(self, subconfig):
-                if tiramisu_value == [] and \
+        for option, value in subconfig.items():
-                        option.option.ismulti():  # and \
+            if option.isoptiondescription():
-                        # option.owner.isdefault():
+                self._parse(value)
-                    tiramisu_value = None
+            elif not option.issymlinkoption():
-                super().__setattr__(tiramisu_key, tiramisu_value)
+                if value == [] and option.ismulti():
+                    value = None
+                super().__setattr__(option.path(), value)
 
     def __setattr__(self,
                     key: str,
-                    value: Any) -> None:
+                    value: Any,
+                    ) -> None:
         if key in self.list_force_no:
             true_key = self.list_force_no[key]
         elif key in self.list_force_del:
@@ -84,13 +86,17 @@ class TiramisuNamespace(Namespace):
         else:
             true_key = key
         option = self._config.option(true_key)
-        if option.option.isfollower():
+        if option.isfollower():
             _setattr = self._setattr_follower
+            if not value[0].isdecimal():
+                raise ValueError('index must be a number, not {}'.format(value[0]))
+            index = int(value[0])
+            option = self._config.option(true_key, index)
             true_value = ','.join(value[1:])
         else:
             _setattr = self._setattr
             true_value = value
-        if option.option.type() == 'choice':
+        if option.type() == 'choice':
             # HACK if integer in choice
             values = option.value.list()
             if isinstance(value, list):
@@ -112,7 +118,7 @@ class TiramisuNamespace(Namespace):
             else:
                 _setattr(option, true_key, key, value)
         except ValueError as err:
-            if option.option.type() == 'choice':
+            if option.type() == 'choice':
                 values = option.value.list()
                 display_value = ''
                 if isinstance(true_value, list):
@@ -132,7 +138,7 @@ class TiramisuNamespace(Namespace):
                  true_key: str,
                  key: str,
                  value: Any) -> None:
-        if option.option.ismulti() and \
+        if option.ismulti() and \
                 value is not None and \
                 not isinstance(value, list):
             value = [value]
@@ -146,12 +152,10 @@ class TiramisuNamespace(Namespace):
                           true_key: str,
                           key: str,
                           value: Any) -> None:
-        if not value[0].isdecimal():
-            raise ValueError('index must be a number, not {}'.format(value[0]))
         index = int(value[0])
-        if option.option.type() == 'boolean':
+        if option.type() == 'boolean':
             value = key not in self.list_force_no
-        elif option.option.issubmulti():
+        elif option.issubmulti():
             value = value[1:]
         else:
             value = value[1]
@@ -201,7 +205,7 @@ class _BuildKwargs:
         self.force_no = force_no
         self.force_del = force_del
         if (not self.force_no or (not_display and not display_modified_value)) and not self.force_del:
-            description = option.doc()
+            description = option.description()
             if not description:
                 description = description.replace('%', '%%')
             self.kwargs['help'] = description
@@ -278,16 +282,22 @@ class TiramisuCmdlineParser(ArgumentParser):
                  fullpath: bool=True,
                  remove_empty_od: bool=False,
                  display_modified_value: bool=True,
-                 formatter_class=HelpFormatter,
+                 formatter_class=ArgumentDefaultsHelpFormatter,
                  unrestraint: bool=False,
+                 add_no_option_to_boolean: bool=True,
+                 short_name_max_len: int=1,
                  _forhelp: bool=False,
                  **kwargs):
+        if not _forhelp:
+            unrestraint = True
         self.fullpath = fullpath
         self.config = config
         self.root = root
         self.remove_empty_od = remove_empty_od
         self.unrestraint = unrestraint
+        self.add_no_option_to_boolean = add_no_option_to_boolean
         self.display_modified_value = display_modified_value
+        self.short_name_max_len = short_name_max_len
         if TiramisuHelpFormatter not in formatter_class.__mro__:
             formatter_class = type('TiramisuHelpFormatter', (TiramisuHelpFormatter, formatter_class), {})
         formatter_class.remove_empty_od = self.remove_empty_od
@@ -297,7 +307,7 @@ class TiramisuCmdlineParser(ArgumentParser):
         else:
             subconfig = self.config
         if self.root is None:
-            subconfig = subconfig.option
+            subconfig = subconfig
         else:
             subconfig = subconfig.option(self.root)
         self.namespace = TiramisuNamespace(self.config, self.root)
@@ -305,7 +315,8 @@ class TiramisuCmdlineParser(ArgumentParser):
         self.register('action', 'help', _TiramisuHelpAction)
         self._config_to_argparser(_forhelp,
                                   subconfig,
-                                  self.root)
+                                  self.root,
+                                  )
 
     def _pop_action_class(self, kwargs, default=None):
         ret = super()._pop_action_class(kwargs, default)
@@ -330,7 +341,7 @@ class TiramisuCmdlineParser(ArgumentParser):
         return super()._match_arguments_partial(actions, arg_string_pattern)
 
     def _is_short_name(self, name, longargument):
-        return len(name) == 1 and not longargument
+        return len(name) <= self.short_name_max_len and not longargument
 
     def _gen_argument(self, name, is_short_name):
         if is_short_name:
@@ -354,6 +365,8 @@ class TiramisuCmdlineParser(ArgumentParser):
                                                epilog=self.epilog,
                                                description=self.description,
                                                unrestraint=self.unrestraint,
+                                               add_no_option_to_boolean=self.add_no_option_to_boolean,
+                                               short_name_max_len=self.short_name_max_len,
                                                fullpath=self.fullpath)
             namespace_, args_ = new_parser._parse_known_args(args_, new_parser.namespace)
         else:
@@ -396,32 +409,37 @@ class TiramisuCmdlineParser(ArgumentParser):
                      prefix: Optional[str],
                      _forhelp: bool,
                      group, level):
-        for obj in config.list(type='all'):
+        for obj in config:
             # do not display frozen option
-            if 'frozen' in obj.option.properties():
+            if 'frozen' in obj.property.get():
                 continue
-            if obj.option.isoptiondescription():
+            if obj.isoptiondescription():
                 if _forhelp:
-                    newgroup = self.add_argument_group(obj.option.path(), obj.option.description())
+                    description = obj.description()
+                    if description == obj.name():
+                        description = None
+                    newgroup = self.add_argument_group(obj.path(), description)
                 else:
                     newgroup = group
                 if prefix:
-                    prefix_ = prefix + '.' + obj.option.name()
+                    prefix_ = prefix + '.' + obj.name()
                 else:
-                    prefix_ = obj.option.path()
+                    prefix_ = obj.path()
                 self._config_to_argparser(_forhelp, obj, prefix_, newgroup, level + 1)
-            elif obj.option.type() == 'boolean' and not obj.option.issymlinkoption():
+            elif self.add_no_option_to_boolean and obj.type() == 'boolean' and not obj.issymlinkoption():
-                if not obj.option.isleader():
+                if not obj.isleader():
                     yield obj, False, None
                     yield obj, True, None
                 else:
                     yield obj, False, False
                     yield obj, False, True
                     yield obj, True, None
-            elif obj.option.isleader():
+            elif obj.isleader():
                 yield obj, None, False
                 yield obj, None, True
             else:
+                if obj.type() == 'boolean' and obj.value.default() is True:
+                    raise ValueError(_(f'the boolean "{obj.path()}" cannot have a default value to True with option add_no_option_to_boolean'))
                 yield obj, None, None
 
     def _config_to_argparser(self,
@@ -435,13 +453,12 @@ class TiramisuCmdlineParser(ArgumentParser):
         actions = {}
         leadership_len = None
         options_is_not_default = {}
-        for obj, force_no, force_del in self._config_list(config, prefix, _forhelp, group, level):
+        for option, force_no, force_del in self._config_list(config, prefix, _forhelp, group, level):
-            option = obj.option
             name = option.name()
             if name.startswith(self.prefix_chars):
                 raise ValueError(_('name cannot startswith "{}"').format(self.prefix_chars))
             if option.issymlinkoption():
-                symlink_name = option.name(follow_symlink=True)
+                symlink_name = option.option().name()
                 if symlink_name in options_is_not_default:
                     options_is_not_default[symlink_name]['name'] = name
                 if symlink_name in actions:
@@ -451,30 +468,28 @@ class TiramisuCmdlineParser(ArgumentParser):
             if force_del:
                 value = None
             elif option.isleader():
-                value = obj.value.get()
+                value = option.value.get()
                 leadership_len = len(value)
             elif option.isfollower():
                 value = []
                 try:
                     for index in range(leadership_len):
-                        value.append(self.config.option(obj.option.path(), index).value.get())
+                        value.append(self.config.option(option.path(), index).value.get())
                 except:
                     value = None
             else:
-                value = obj.value.get()
+                value = option.value.get()
             if self.fullpath and prefix:
                 name = prefix + '.' + name
-            if option.isfollower():
+            properties = option.property.get()
-                properties = obj.option.properties()
+            not_display = not option.isfollower() and not option.owner.isdefault() and value is not None
-            else:
-                properties = obj.property.get()
-            not_display = not option.isfollower() and not obj.owner.isdefault() and value is not None
             kwargs = _BuildKwargs(name, option, self, properties, force_no, force_del, self.display_modified_value, not_display)
             if _forhelp and not_display and ((value is not False and not force_no) or (value is False and force_no)):
                 options_is_not_default[option.name()] = {'properties': properties,
                                                          'type': option.type(),
                                                          'name': name,
-                                                         'value': value}
+                                                         'value': value,
+                                                         }
                 if not self.display_modified_value:
                     continue
             if 'positional' in properties:
@@ -483,10 +498,17 @@ class TiramisuCmdlineParser(ArgumentParser):
                 if not 'mandatory' in properties:
                     raise ValueError('"positional" argument must be "mandatory" too')
                 if _forhelp:
-                    kwargs['default'] = obj.value.default()
+                    kwargs['default'] = option.value.default()
                 else:
                     kwargs['default'] = value
                     kwargs['nargs'] = '?'
+            else:
+                if _forhelp and not option.isleader():
+                    default = option.value.default()
+                    if default not in [None, []]:
+                        kwargs['default'] = default
+                    else:
+                        kwargs['default'] = SUPPRESS
                 else:
                     kwargs['default'] = SUPPRESS
                 if _forhelp and 'mandatory' in properties:
@@ -508,7 +530,7 @@ class TiramisuCmdlineParser(ArgumentParser):
             if option.type() != 'boolean' or force_del:
                 if not force_del:
                     if _forhelp:
-                        value = obj.value.default()
+                        value = option.value.default()
                     if value not in [None, []]:
                         #kwargs['default'] = kwargs['const'] = option.default()
                         #kwargs['action'] = 'store_const'
@@ -529,7 +551,7 @@ class TiramisuCmdlineParser(ArgumentParser):
                             metavar = '[{}]'.format(metavar)
                     if option.type() == 'choice':
                         # do not manage choice with argparse there is problem with integer problem
-                        kwargs['metavar'] = ('INDEX', get_choice_list(obj, properties, True))
+                        kwargs['metavar'] = ('INDEX', get_choice_list(option, properties, True))
                     else:
                         kwargs['metavar'] = ('INDEX', metavar)
                 if force_del:
@@ -545,7 +567,7 @@ class TiramisuCmdlineParser(ArgumentParser):
                         kwargs['nargs'] = 1
                 elif option.type() == 'choice' and not option.isfollower():
                     # do not manage choice with argparse there is problem with integer problem
-                    kwargs['choices'] = get_choice_list(obj, properties, False)
+                    kwargs['choices'] = get_choice_list(option, properties, False)
                 elif option.type() == 'float':
                     kwargs['type'] = float
                 else:
@@ -581,23 +603,23 @@ class TiramisuCmdlineParser(ArgumentParser):
                 self.error('unrecognized arguments: {}'.format(name))
         if valid_mandatory:
             errors = []
-            for key in self.config.value.mandatory():
+            for option in self.config.value.mandatory():
-                properties = self.config.option(key).option.properties()
+                properties = option.property.get()
-                if not self.config.option(key).option.isfollower():
+                if not option.isfollower():
                     if 'positional' not in properties:
-                        if self.fullpath or '.' not in key:
+                        if self.fullpath:
-                            name = key
+                            name = option.path()
                         else:
-                            name = key.rsplit('.', 1)[1]
+                            name = option.name()
-                        is_short_name = self._is_short_name(name, 'longargument' in self.config.option(key).property.get())
+                        is_short_name = self._is_short_name(name, 'longargument' in option.property.get())
                         args = self._gen_argument(name, is_short_name)
                     else:
-                        args = key
+                        args = option.path()
                 else:
                     if 'positional' not in properties:
-                        args = self._gen_argument(key, False)
+                        args = self._gen_argument(option.path(), False)
                     else:
-                        args = key
+                        args = option.path()
                 if not self.fullpath and '.' in args:
                     args = args.rsplit('.', 1)[1]
                     if 'positional' not in properties:
@@ -617,6 +639,8 @@ class TiramisuCmdlineParser(ArgumentParser):
                                                remove_empty_od=self.remove_empty_od,
                                                display_modified_value=self.display_modified_value,
                                                formatter_class=self.formatter_class,
+                                               add_no_option_to_boolean=self.add_no_option_to_boolean,
+                                               short_name_max_len=self.short_name_max_len,
                                                epilog=self.epilog,
                                                description=self.description,
                                                _forhelp=True)
@@ -630,6 +654,8 @@ class TiramisuCmdlineParser(ArgumentParser):
                                                remove_empty_od=self.remove_empty_od,
                                                display_modified_value=self.display_modified_value,
                                                formatter_class=self.formatter_class,
+                                               add_no_option_to_boolean=self.add_no_option_to_boolean,
+                                               short_name_max_len=self.short_name_max_len,
                                                epilog=self.epilog,
                                                description=self.description,
                                                _forhelp=True)