tiramisu-cmdline-parser => python3-tiramisu-cmdline-parser

Create module directory and add setup.py to project.

See merge request tiramisu/tiramisu-cmdline-parser!1

debian/agpl-3

@@ -0,0 +1,662 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.
+

debian/compat

@@ -0,0 +1 @@
+11

debian/control

@@ -0,0 +1,14 @@
+Source: tiramisu-cmdline-parser
+Section: admin
+Priority: extra
+Maintainer: Cadoles <contact@cadoles.com>
+Build-depends: debhelper (>=11), python3-all, python3-setuptools, dh-python
+Standards-Version: 3.9.4
+Homepage: https://framagit.org/tiramisu/tiramisu-cmdline-parser
+
+Package: python3-tiramisu-cmdline-parser
+Architecture: any
+Pre-Depends: dpkg, python3, ${misc:Pre-Depends}, python3-tiramisu-api
+Depends: ${python:Depends}, ${misc:Depends}
+Description: Command line parser with argument validation
+

debian/copyright

@@ -0,0 +1,22 @@
+Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: risotto
+Upstream-Contact: Cadoles <contact@cadoles.com>
+Source: https://forge.cadoles.com/Infra/risotto
+
+Files: *
+Copyright: 2019-2020 Cadoles <contact@cadoles.com>
+License: AGPL-3+
+
+License: AGPL-3+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ .
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+ .
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.

debian/rules

@@ -0,0 +1,16 @@
+#!/usr/bin/make -f
+# See debhelper(7) (uncomment to enable)
+# output every command that modifies files on the build system.
+#DH_VERBOSE = 1
+
+export PYBUILD_NAME = tiramisu_cmdline_parser
+export PYBUILD_DISABLE_python3 = test
+
+%:
+	dh $@ --with python3 --buildsystem=pybuild
+
+
+override_dh_build:
+	find ./ -type f -wholename "**/__pycache__/*" -delete
+	find ./ -type d -name __pycache__ -delete
+	dh build --with python3 --buildsystem=pybuild

debian/source/format

@@ -0,0 +1 @@
+3.0 (quilt)

examples/AmonEcole/eosfunc.py

@@ -0,0 +1,303 @@
+import re, random, ipaddress
+def get_version(*args, **kwargs):
+    return u'2.6.2'
+
+
+def is_instanciate(*args, **kwargs):
+    return 'oui'
+
+
+def calc_val(valeur):
+    return valeur
+
+
+def concat(*args, **kwargs):
+    """ concatène deux valeurs """
+    sortedkeys = list(kwargs.keys())
+    sortedkeys.sort()
+    sortedkwvalues = []
+    for key in sortedkeys:
+        if kwargs[key] == '' or kwargs[key] is None:
+            return None
+        sortedkwvalues.append(kwargs[key])
+    if None in args:
+        return None
+    return "".join(args)+''.join(sortedkwvalues)
+
+
+def auto_dns(*args, **kwargs):
+    return []
+
+
+def calc_multi_condition(param, match=None, mismatch=None, operator='AND',
+                         default_match=None, default_mismatch=None,
+                         eval_match='False', eval_mismatch='False',
+                         **conditions):
+    if operator not in ('AND', 'OR'):
+        raise ValueError(_(u'Operator must be either "AND" or "OR"'))
+    if eval_match not in ('True', 'False'):
+        raise ValueError(_(u'eval_match must be either "True" or "False"'))
+    if eval_mismatch not in ('True', 'False'):
+        raise ValueError(_(u'eval_mismatch must be either "True" or "False"'))
+    if match is None:
+        if default_match is None:
+            match = u'oui'
+        else:
+            if default_match == 'None':
+                match = None
+            else:
+                match = default_match
+    if mismatch is None:
+        if default_mismatch is None:
+            mismatch = u'non'
+        else:
+            if default_mismatch == 'None':
+                mismatch = None
+            else:
+                mismatch = default_mismatch
+    conditions_keys = list(conditions.keys())
+    conditions_keys.sort()
+    for condition in conditions_keys:
+        if not condition.startswith('condition_'):
+            raise ValueError(_(u'Condition keys must start with "condition".'))
+    # si le paramètre est une liste...
+    if param.startswith('['):
+        param = eval(param)
+    # si il faut évaluer le résultat à retourner...
+    if eval_match == 'True':
+        match = eval(match)
+    if eval_mismatch == 'True':
+        mismatch = eval(mismatch)
+    if isinstance(param, list) and len(param) != len(conditions):
+        raise ValueError(_(u'Conditions and parameters counts do not match in calc_multi_condition.'))
+    for num in range(0, len(conditions)):
+        key = conditions_keys[num]
+        value = conditions[key]
+        if not isinstance(param, list):
+            if operator == 'AND' and value != param:
+                return mismatch
+            if operator == 'OR' and value == param:
+                return match
+        else:
+            if operator == 'AND' and value != param[num]:
+                return mismatch
+            if operator == 'OR' and value == param[num]:
+                return match
+    if operator == 'AND':
+        return match
+    else:
+        return mismatch
+
+
+auto_copy_val = calc_val
+
+
+def activate_master_only_web_app(*args, **kwargs):
+    return 'oui'
+
+
+def calc_val_first_value(*args, **kwargs):
+    if args == tuple():
+        return None
+    return args[0]
+
+
+def valid_entier(*args, **kwargs):
+    return True
+
+
+def list_cdrom_devices(*args, **kwargs):
+    return 'cdrom'
+
+
+def cdrom_minormajor(*args, **kwargs):
+    return 0
+
+
+def calc_free_PE(*args, **kwargs):
+    return 0
+
+
+def enable_lv_creation(*args, **kwargs):
+    return "oui"
+
+
+def get_lv_names(*args, **kwargs):
+    return "lvm"
+
+
+def calc_multi_val(*args, **kwargs):
+    res = []
+    for arg in args:
+        if arg is None:
+            if kwargs.get('allow_none', u'False') == u'True':
+                continue
+            else:
+                return []
+        # gestion des valeurs multi
+        if isinstance(arg, list):
+            for ev_arg in arg:
+                if ev_arg is not None and ev_arg not in res:
+                    res.append(ev_arg)
+        else:
+            res.append(arg)
+    return res
+
+
+def check_partitioning_auto_extend(*args, **kwargs):
+    return 'non'
+
+
+def check_free_space(*args, **kwargs):
+    return 0
+
+
+def is_fs_type(*args, **kwargs):
+    return "ext4"
+
+
+def is_lv_name(*args, **kwargs):
+    return "/etc"
+
+
+def get_net_device(*args, **kwargs):
+    return 'eth' + str(args[0])
+
+
+def list_len_gt(param, max_len=None, match=None, mismatch=None,
+                default_match=None, default_mismatch=None,
+                eval_match='False', eval_mismatch='False',):
+    if match is None:
+        if default_match is None:
+            match = u'oui'
+        else:
+            if default_match == 'None':
+                match = None
+            else:
+                match = default_match
+    if mismatch is None:
+        if default_mismatch is None:
+            mismatch = u'non'
+        else:
+            if default_mismatch == 'None':
+                mismatch = None
+            else:
+                mismatch = default_mismatch
+    # si il faut évaluer le résultat à retourner...
+    if eval_match == 'True':
+        match = eval(match)
+    if eval_mismatch == 'True':
+        mismatch = eval(mismatch)
+    if isinstance(param, list):
+        if len(param) > int(max_len):
+            return match
+        else:
+            return mismatch
+    else:
+        return mismatch
+
+
+def get_zone_name_bridge(*args, **kwargs):
+    return "non"
+
+
+def get_zone_name(*args, **kwargs):
+    return 'eth0'
+
+def auto_eth(*args, **kwargs):
+    if kwargs['parametre'] == kwargs['condition']:
+        return "192.168.1.1"
+
+
+def auto_netmask(*args, **kwargs):
+    if kwargs['parametre'] == kwargs['condition']:
+        return "255.255.255.0"
+
+
+def calc_or_auto_network(*args, **kwargs):
+    if kwargs['parametre'] == kwargs['condition']:
+        return "192.168.1.0"
+    return calc_network(kwargs['ip'], kwargs['netmask'])
+
+
+def calc_or_auto_broadcast(*args, **kwargs):
+    if kwargs['parametre'] == kwargs['condition']:
+        return "192.168.1.255"
+
+
+def auto_defaultgw_ip(*args, **kwargs):
+    if args[0] != 'statique':
+        return "192.168.1.254"
+
+
+def calc_network(ip, netmask):
+    if None not in (ip, netmask):
+        try:
+            return str(ipaddress.ip_interface('{}/{}'.format(ip, netmask)).network.network_address)
+        except:
+            return None
+
+
+def calc_broadcast(ip, netmask):
+    if None not in (ip, netmask):
+        return str(ipaddress.ip_interface('{}/{}'.format(ip, netmask)).network.broadcast_address)
+
+
+def calc_ssl_country_name(*args, **kwargs):
+    return 'FR'
+
+
+def valid_country(*args, **kwargs):
+    return
+
+
+def valid_regexp(data, exp_reg, err_msg=u"Invalid syntax"):
+    if data == "":
+        return True
+    match = re.match(exp_reg, data)
+    if match is None:
+        raise ValueError(err_msg)
+    else:
+        return True
+
+
+def gen_random(*args, **kwargs):
+    return '4444444444444444444'
+
+
+def check_name_uniq(value, values, index):
+    values.pop(index)
+    if value in values:
+        raise ValueError('le nom {} est déjà attribué à une autre plage'.format(value))
+
+
+def calc_classe(*args, **kwargs):
+    return "24"
+
+
+def calc_webredirection(*args, **kwargs):
+    return "/toto"
+
+
+def calc_container(mode_container, container_info, mode_zephir='non'):
+    return container_info
+
+
+def calc_libelle_annuaire(*args, **kwargs):
+    return "LDAP label"
+
+
+def valid_differ(data, value):
+    if data == value:
+        raise ValueError(u"Value must be different from {0}".format(value))
+
+
+def device_type(*args, **kwargs):
+    return 'b'
+
+
+def random_int(vmin, vmax, exclude=None):
+    values = list(range(int(vmin), int(vmax)+1))
+    if exclude != None and exclude in values:
+        values.remove(exclude)
+    return random.choice(values)

examples/AmonEcole/example.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+"""AmonEcole example
+"""
+
+from examples.AmonEcole import amonecole
+from tiramisu_cmdline_parser import TiramisuCmdlineParser
+from tiramisu import default_storage
+
+
+def display_name(option, dyn_name):
+    return "--" + option.impl_getpath()
+
+
+def main():
+    """AmonEcole
+    """
+    default_storage.setting(engine='sqlite3', name='amonecole_cmdline_parser')
+    config = amonecole.get_config(display_name=display_name)
+    config.property.read_write()
+    config.property.pop('expert')
+    config.property.pop('normal')
+    config.property.add('expert')
+    config.property.add('normal')
+    config.permissive.add('expert')
+    config.permissive.add('normal')
+    parser = TiramisuCmdlineParser(config, root='creole')
+    #parser.parse_args(valid_mandatory=False)
+    parser.parse_args()
+
+
+if __name__ == "__main__":
+    main()

examples/Hangman/example.py

@@ -8,9 +8,7 @@ import unicodedata
 import re
 from os import unlink
 from os.path import isfile
-from tiramisu import RegexpOption, OptionDescription, Config, IntOption, UnicodeOption, BoolOption, ParamOption, Params
-from tiramisu.storage import storage_type
-from tiramisu.storage.sqlite3.storage import SETTING
+from tiramisu import RegexpOption, OptionDescription, Config, IntOption, UnicodeOption, BoolOption, ParamOption, Params, default_storage
 from tiramisu_cmdline_parser import TiramisuCmdlineParser
 
 
@@ -120,7 +118,7 @@ def main():
         proposal = ProposalOption('guess{}'.format(idx),
                                   'Guess {}'.format(idx),
                                   requires=requires,
-                                  properties=('positional',))
+                                  properties=('positional', 'mandatory'))
         #FIXME maximum recursion ...
         #if proposals:
         #    proposal.impl_add_consistency('not_equal', proposals[0])
@@ -147,15 +145,16 @@ def main():
     #descr = OptionDescription('proposals',
     #                          'Suggesting letters',
     #                          options)
-    storage_type.set('sqlite3')
+    default_storage.setting(engine='sqlite3', name='hangman_cmdline_parser')
     config = Config(OptionDescription('root', 'root', [word, proposal_word, misses, proposals_left] + options), persistent=True, session_id='hangman')
-    parser = TiramisuCmdlineParser(config)
+    config.property.read_write()
     try:
-        parser.parse_args()
+        parser = TiramisuCmdlineParser(config)
+        parser.parse_args(valid_mandatory=False)
     except ValueError:
+        # if no more suggestion
         pass
-    config = parser.get_config()
-    filename = '{}/tiramisu.db'.format(SETTING.dir_database)
+    filename = '/tmp/tiramisu.db'
     lost = False
     for name in ['proposal_word', 'misses', 'proposals_left']:
         option = config.option(name)

setup.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from setuptools import setup, find_packages
+import os
+from tiramisu_cmdline_parser import __version__
+
+
+PACKAGE_NAME = os.environ.get('PACKAGE_DST', 'tiramisu_cmdline_parser')
+
+setup(
+    version=__version__,
+    author="Tiramisu's team",
+    author_email='gnunux@gnunux.info',
+    name=PACKAGE_NAME,
+    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"],
+	classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)",
+        "Operating System :: OS Independent",
+	    "Natural Language :: English",
+        "Natural Language :: French",
+	    ],
+	long_description="""\
+tiramisu-cmdline-parser
+---------------------------------
+
+Python3 parser for command-line options and arguments using Tiramisu engine.
+""",
+    include_package_data=True,
+    packages=find_packages(include=['tiramisu_cmdline_parser'])
+)

test/test_readme.py

@@ -1,210 +0,0 @@
-from io import StringIO
-from contextlib import redirect_stdout, redirect_stderr
-
-
-from tiramisu_cmdline_parser import TiramisuCmdlineParser
-from tiramisu import IntOption, StrOption, BoolOption, ChoiceOption, \
-                     SymLinkOption, OptionDescription, Config
-
-
-def get_config():
-    choiceoption = ChoiceOption('cmd',
-                                'choice the sub argument',
-                                ('str', 'list', 'int'),
-                                properties=('mandatory',
-                                            'positional'))
-    booloption = BoolOption('verbosity',
-                            'increase output verbosity',
-                            default=False)
-    short_booloption = SymLinkOption('v', booloption)
-    str_ = StrOption('str',
-                     'string option',
-                     properties=('mandatory',),
-                     requires=[{'option': choiceoption,
-                                'expected': 'str',
-                                'action': 'disabled',
-                                'inverse': True}])
-    list_ = StrOption('list',
-                      'list string option',
-                      multi=True,
-                      properties=('mandatory',),
-                      requires=[{'option': choiceoption,
-                                 'expected': 'list',
-                                 'action': 'disabled',
-                                 'inverse': True}])
-    int_ = IntOption('int',
-                     'int option',
-                     properties=('mandatory',),
-                     requires=[{'option': choiceoption,
-                                'expected': 'int',
-                                'action': 'disabled',
-                                'inverse': True}])
-    return Config(OptionDescription('root',
-                                    'root',
-                                    [choiceoption,
-                                     booloption,
-                                     short_booloption,
-                                     str_,
-                                     list_,
-                                     int_
-                                     ]))
-
-def test_readme_help():
-    output = """usage: prog.py [-h] [-v] --str STR --list LIST [LIST ...] --int INT
-               {str,list,int}
-
-positional arguments:
-  {str,list,int}        choice the sub argument
-
-optional arguments:
-  -h, --help            show this help message and exit
-  -v, --verbosity       increase output verbosity
-  --str STR             string option
-  --list LIST [LIST ...]
-                        list string option
-  --int INT             int option
-"""
-    parser = TiramisuCmdlineParser('prog.py')
-    parser.add_arguments(get_config())
-    f = StringIO()
-    with redirect_stdout(f):
-        parser.print_help()
-    assert f.getvalue() == output
-
-
-def test_readme_positional_mandatory():
-    output = """usage: prog.py [-h] [-v] --str STR --list LIST [LIST ...] --int INT
-               {str,list,int}
-prog.py: error: the following arguments are required: cmd
-"""
-    parser = TiramisuCmdlineParser('prog.py')
-    parser.add_arguments(get_config())
-    f = StringIO()
-    with redirect_stderr(f):
-        try:
-            parser.parse_args([])
-        except SystemExit as err:
-            assert str(err) == "2"
-        else:
-            raise Exception('must raises')
-    assert f.getvalue() == output
-
-
-def test_readme_mandatory():
-    output = """usage: prog.py [-h] [-v] --str STR --list LIST [LIST ...] --int INT
-               {str,list,int}
-prog.py: error: the following arguments are required: --str
-"""
-    parser = TiramisuCmdlineParser('prog.py')
-    parser.add_arguments(get_config())
-    f = StringIO()
-    with redirect_stderr(f):
-        try:
-            parser.parse_args(['str'])
-        except SystemExit as err:
-            assert str(err) == "2"
-        else:
-            raise Exception('must raises')
-    assert f.getvalue() == output
-
-
-def test_readme_cross():
-    output = """usage: prog.py [-h] [-v] --str STR --list LIST [LIST ...] --int INT
-               {str,list,int}
-prog.py: error: unrecognized arguments: --int
-"""
-    parser = TiramisuCmdlineParser('prog.py')
-    parser.add_arguments(get_config())
-    f = StringIO()
-    with redirect_stderr(f):
-        try:
-            parser.parse_args(['str', '--int', '3'])
-        except SystemExit as err:
-            assert str(err) == "2"
-        else:
-            raise Exception('must raises')
-    assert f.getvalue() == output
-
-
-def test_readme_int():
-    output = {'cmd': 'int',
-              'int': 3,
-              'verbosity': False,
-              'v': False}
-    config = get_config()
-    parser = TiramisuCmdlineParser('prog.py')
-    parser.add_arguments(config)
-    parser.parse_args(['int', '--int', '3'])
-    assert config.value.dict() == output
-
-
-def test_readme_int_verbosity():
-    output = {'cmd': 'int',
-              'int': 3,
-              'verbosity': True,
-              'v': True}
-    config = get_config()
-    parser = TiramisuCmdlineParser('prog.py')
-    parser.add_arguments(config)
-    parser.parse_args(['int', '--int', '3', '--verbosity'])
-    assert config.value.dict() == output
-
-
-def test_readme_int_verbosity_short():
-    output = {'cmd': 'int',
-              'int': 3,
-              'verbosity': True,
-              'v': True}
-    config = get_config()
-    parser = TiramisuCmdlineParser('prog.py')
-    parser.add_arguments(config)
-    parser.parse_args(['int', '--int', '3', '-v'])
-    assert config.value.dict() == output
-
-
-def test_readme_str():
-    output = {'cmd': 'str',
-              'str': 'value',
-              'verbosity': False,
-              'v': False}
-    config = get_config()
-    parser = TiramisuCmdlineParser('prog.py')
-    parser.add_arguments(config)
-    parser.parse_args(['str', '--str', 'value'])
-    assert config.value.dict() == output
-
-
-def test_readme_str_int():
-    output = {'cmd': 'str',
-              'str': '3',
-              'verbosity': False,
-              'v': False}
-    config = get_config()
-    parser = TiramisuCmdlineParser('prog.py')
-    parser.add_arguments(config)
-    parser.parse_args(['str', '--str', '3'])
-    assert config.value.dict() == output
-
-
-def test_readme_list():
-    output = {'cmd': 'list',
-              'list': ['a', 'b', 'c'],
-              'verbosity': False,
-              'v': False}
-    config = get_config()
-    parser = TiramisuCmdlineParser('prog.py')
-    parser.add_arguments(config)
-    parser.parse_args(['list', '--list', 'a', 'b', 'c'])
-    assert config.value.dict() == output
-
-
-def test_readme_list_uniq():
-    output = {'cmd': 'list',
-              'list': ['a'],
-              'verbosity': False,
-              'v': False}
-    config = get_config()
-    parser = TiramisuCmdlineParser('prog.py')
-    parser.add_arguments(config)
-    parser.parse_args(['list', '--list', 'a'])
-    assert config.value.dict() == output

test/test_simple.py

@@ -1,155 +0,0 @@
-from tiramisu import StrOption, BoolOption, IntOption, ChoiceOption, OptionDescription, SymLinkOption
-from py.test import raises, fixture
-from io import StringIO
-import sys
-from os import listdir
-from os.path import join, isdir
-from contextlib import redirect_stdout, redirect_stderr
-from argparse import ArgumentParser
-
-#from pouet import TiramisuCmdlineParser
-from tiramisu_cmdline_parser import TiramisuCmdlineParser
-
-
-DATA_DIR = 'test/data/compare'
-TEST_DIRS = []
-
-
-for test in listdir(DATA_DIR):
-    test_file = join(DATA_DIR, test)
-    if isdir(test_file):
-        TEST_DIRS.append(test_file)
-
-TEST_DIRS.sort()
-# TEST_DIRS.remove('test/data/compare/10_positional_list')
-# TEST_DIRS = ['test/data/compare/10_positional_list']
-
-
-@fixture(scope="module", params=TEST_DIRS)
-def test_list(request):
-    return request.param
-
-
-def import_subfile_and_test(filename, parser, arg):
-    parser_dict = []
-    parser_system_err = []
-    f = StringIO()
-    with redirect_stderr(f):
-        exec(open(filename).read())
-        # print('arg', arg)
-        try:
-            parser_dict.append(parser.parse_args(arg).__dict__)
-        except SystemExit as err:
-            parser_system_err.append(str(err))
-        else:
-            parser_system_err.append(None)
-    parser_error = f.getvalue()
-    f = StringIO()
-    with redirect_stdout(f):
-        parser.print_help()
-    parser_help = f.getvalue()
-    return parser_dict, parser_system_err, parser_error, parser_help
-
-
-def test_files(test_list):
-    args = [[],
-            # 10_positional
-            ['bar'], ['foo', 'bar'],
-            # 10_positional_int
-            ['4'],
-            # 20_bool
-            ['--verbosity'], ['--verbosity', 'arg'],
-            # 20_string
-            ['--foo'], ['--foo', '--bar'], ['--foo', 'a'],
-            ['--foo', 'a', '--foo', 'b'],
-            # 20_int
-            ['--int', '3'], ['--int', 'a'],
-            # 20 choice
-            ['--door', 'a'], ['--door', '1'],
-            # 30_string_short
-            ['-f', 'b'], ['--foo', 'c', '-f', 'b'],
-            # 40 multi_bool
-            ['-v'], ['-v', '-s'], ['-vs'],
-            # 40_short_long
-            ['-v', '--foo', '1'], ['-vf', '2'], ['-vf'], ['-vf', '-v'],
-            # 40_positional_optional
-            ['bar', '--verbosity'], ['--verbosity', 'bar'],
-            ]
-    for arg in args:
-        # FIXME unknown argument is check before mandatory
-        if test_list == 'test/data/compare/10_positional_list':
-            check = False
-            for subarg in arg:
-                if not subarg.startswith('-'):
-                    check = True
-                    break
-            if not check:
-                continue
-        tiramparser = TiramisuCmdlineParser('prog.py')
-        tiramparser_dict, tiramparser_system_err, tiramparser_error, tiramparser_help = import_subfile_and_test(test_list + '/tiramisu.py',
-                                                                                                                tiramparser, arg)
-        #
-        argparser = ArgumentParser('prog.py')
-        argparser_dict, argparser_system_err, argparser_error, argparser_help = import_subfile_and_test(test_list + '/argparse.py',
-                                                                                                        argparser, arg)
-        # print('===>', test_list, arg)
-        # print(tiramparser_dict)
-        # print(tiramparser_system_err)
-        # print(tiramparser_error)
-        # print(tiramparser_help)
-        # print('-----')
-        # print(argparser_dict)
-        # print(argparser_system_err)
-        # print(argparser_error)
-        # print(argparser_help)
-        assert tiramparser_dict == argparser_dict
-        assert tiramparser_error == argparser_error
-        assert tiramparser_help == argparser_help
-        assert tiramparser_system_err == argparser_system_err
-
-
-#FIXME --verbose sans --quiet
-#parser = argparse.ArgumentParser(description="calculate X to the power of Y")
-#group = parser.add_mutually_exclusive_group()
-#group.add_argument("-v", "--verbose", action="store_true")
-#group.add_argument("-q", "--quiet", action="store_true")
-#parser.add_argument("x", type=int, help="the base")
-#parser.add_argument("y", type=int, help="the exponent")
-#args = parser.parse_args()
-#answer = args.x**args.y
-
-
-#FIXME --sum ?
-#parser = argparse.ArgumentParser(description='Process some integers.')
-#parser.add_argument('integers', metavar='N', type=int, nargs='+',
-#                    help='an integer for the accumulator')
-#parser.add_argument('--sum', dest='accumulate', action='store_const',
-#                    const=sum, default=max,
-#                    help='sum the integers (default: find the max)')
-#args = parser.parse_args()
-#print(args.accumulate(args.integers))
-
-
-# +++++++++++++++++++++++++++++ nargs
-#FIXME longueur fixe
-#>>> parser = argparse.ArgumentParser()
-#>>> parser.add_argument('--foo', nargs=2)
-#>>> parser.add_argument('bar', nargs=1)
-#>>> parser.parse_args('c --foo a b'.split())
-#Namespace(bar=['c'], foo=['a', 'b'])
-
-
-#FIXME const
-#>>> parser = argparse.ArgumentParser()
-#>>> parser.add_argument('--foo', nargs='?', const='c', default='d')
-#>>> parser.add_argument('bar', nargs='?', default='d')
-#>>> parser.parse_args(['XX', '--foo', 'YY'])
-#Namespace(bar='XX', foo='YY')
-#>>> parser.parse_args(['XX', '--foo'])
-#Namespace(bar='XX', foo='c')
-#>>> parser.parse_args([])
-#Namespace(bar='d', foo='d')
-
-#FIXME ? | * | +
-# * == list
-# + == list + mandatory

tests/test_choice.py

@@ -0,0 +1,207 @@
+from io import StringIO
+from contextlib import redirect_stdout, redirect_stderr
+import pytest
+
+
+from tiramisu_cmdline_parser import TiramisuCmdlineParser
+from tiramisu import ChoiceOption, OptionDescription, Config
+try:
+    from tiramisu_api import Config as JsonConfig
+    params = ['tiramisu', 'tiramisu-json']
+except:
+    params = ['tiramisu']
+
+
+
+def get_config(json):
+    positional = ChoiceOption('positional',
+                              'choice the sub argument',
+                              ('str', 'list', 'int', 'none'),
+                              properties=('positional', 'mandatory'))
+    positional_int = ChoiceOption('positional_int',
+                              'choice the sub argument',
+                              (1, 2, 3),
+                              properties=('positional', 'mandatory'))
+    str_ = ChoiceOption('str',
+                        'choice the sub argument',
+                        ('str1', 'str2', 'str3'))
+    int_ = ChoiceOption('int',
+                        'choice the sub argument',
+                        (1, 2, 3))
+    int_multi = ChoiceOption('int_multi',
+                             'choice the sub argument',
+                             (1, 2, 3),
+                             multi=True)
+    od = OptionDescription('od',
+                           'od',
+                           [positional, positional_int, str_, int_, int_multi])
+    config = Config(od)
+    config.property.read_write()
+    if json == 'tiramisu':
+        return config
+    jconfig = JsonConfig(config.option.dict())
+    return jconfig
+
+
+@pytest.fixture(params=params)
+def json(request):
+    return request.param
+
+
+def test_choice_positional(json):
+    output1 = '''usage: prog.py "str" "1" [-h] [--str {str1,str2,str3}] [--int {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}]
+                         [--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.parse_args(['str', '1'])
+    assert config.value.dict() == {'positional': 'str',
+                                   'positional_int': 1,
+                                   'str': None,
+                                   'int': None,
+                                   'int_multi': []}
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['error', '1'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output1
+
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['str', '4'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output2
+
+
+def test_choice_str(json):
+    output = """usage: prog.py "str" "1" --str "str3" [-h] [--str {str1,str2,str3}]
+                                      [--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.parse_args(['str', '1', '--str', 'str1'])
+    assert config.value.dict() == {'positional': 'str',
+                                   'positional_int': 1,
+                                   'str': 'str1',
+                                   'int': None,
+                                   'int_multi': []}
+    parser.parse_args(['str', '1', '--str', 'str2'])
+    assert config.value.dict() == {'positional': 'str',
+                                   'positional_int': 1,
+                                   'str': 'str2',
+                                   'int': None,
+                                   'int_multi': []}
+    parser.parse_args(['str', '1', '--str', 'str3'])
+    assert config.value.dict() == {'positional': 'str',
+                                   'positional_int': 1,
+                                   'str': 'str3',
+                                   'int': None,
+                                   'int_multi': []}
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['str', '1', '--str', 'error'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+    assert config.value.dict() == {'positional': 'str',
+                                   'positional_int': 1,
+                                   'str': 'str3',
+                                   'int': None,
+                                   'int_multi': []}
+
+
+def test_choice_int(json):
+    output = """usage: prog.py "str" "1" --int "1" [-h] [--str {str1,str2,str3}]
+                                   [--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.parse_args(['str', '1', '--int', '1'])
+    assert config.value.dict() == {'positional': 'str',
+                                   'positional_int': 1,
+                                   'str': None,
+                                   'int': 1,
+                                   'int_multi': []}
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['str', '1', '--int', '4'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+    assert config.value.dict() == {'positional': 'str',
+                                   'positional_int': 1,
+                                   'str': None,
+                                   'int': 1,
+                                   'int_multi': []}
+
+
+def test_choice_int_multi(json):
+    output = """usage: prog.py "str" "1" --int_multi "1" "2" [-h] [--str {str1,str2,str3}]
+                                             [--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.parse_args(['str', '1', '--int_multi', '1', '2'])
+    assert config.value.dict() == {'positional': 'str',
+                                   'positional_int': 1,
+                                   'str': None,
+                                   'int': None,
+                                   'int_multi': [1, 2]}
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['str', '1', '--int_multi', '4'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+    assert config.value.dict() == {'positional': 'str',
+                                   'positional_int': 1,
+                                   'str': None,
+                                   'int': None,
+                                   'int_multi': [1, 2]}
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['str', '1', '--int_multi', '1', '4'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+    assert config.value.dict() == {'positional': 'str',
+                                   'positional_int': 1,
+                                   'str': None,
+                                   'int': None,
+                                   'int_multi': [1, 2]}

tests/test_help.py

@@ -0,0 +1,99 @@
+from io import StringIO
+from contextlib import redirect_stdout, redirect_stderr
+import pytest
+from argparse import RawDescriptionHelpFormatter
+
+
+from tiramisu_cmdline_parser import TiramisuCmdlineParser
+from tiramisu import IntOption, StrOption, BoolOption, ChoiceOption, \
+                     SymLinkOption, OptionDescription, Config
+try:
+    from tiramisu_api import Config as JsonConfig
+    params = ['tiramisu', 'tiramisu-json']
+except:
+    params = ['tiramisu']
+
+
+
+def get_config(json):
+    choiceoption = ChoiceOption('cmd',
+                                'choice the sub argument',
+                                ('str', 'list', 'int', 'none'),
+                                properties=('mandatory',
+                                            'positional'))
+    od = OptionDescription('od',
+                           'od',
+                           [choiceoption])
+    root = OptionDescription('root',
+                             'root',
+                             [od])
+    config = Config(root)
+    config.property.read_write()
+    if json == 'tiramisu':
+        return config
+    jconfig = JsonConfig(config.option.dict())
+    return jconfig
+
+
+@pytest.fixture(params=params)
+def json(request):
+    return request.param
+
+
+def test_help(json):
+    output = """usage: prog.py [-h] {str,list,int,none}
+
+optional arguments:
+  -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')
+    f = StringIO()
+    with redirect_stdout(f):
+        parser.print_help()
+    assert f.getvalue() == output
+
+
+def test_help_epilog(json):
+    output = """usage: prog.py [-h] {str,list,int,none}
+
+optional arguments:
+  -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")
+    f = StringIO()
+    with redirect_stdout(f):
+        parser.print_help()
+    assert f.getvalue() == output
+
+
+def test_help_epilog_raw(json):
+    output = """usage: prog.py [-h] {str,list,int,none}
+
+optional arguments:
+  -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", formatter_class=RawDescriptionHelpFormatter)
+    f = StringIO()
+    with redirect_stdout(f):
+        parser.print_help()
+    assert f.getvalue() == output

tests/test_leadership.py

@@ -0,0 +1,424 @@
+from io import StringIO
+from contextlib import redirect_stdout, redirect_stderr
+import pytest
+
+
+from tiramisu_cmdline_parser import TiramisuCmdlineParser
+from tiramisu import IntOption, StrOption, BoolOption, ChoiceOption, \
+                     SymLinkOption, OptionDescription, Leadership, Config, submulti
+try:
+    from tiramisu_api import Config as JsonConfig
+    params = ['tiramisu', 'tiramisu-json']
+except:
+    params = ['tiramisu']
+
+
+def get_config(json, with_mandatory=False):
+    leader = StrOption('leader', "Leader var", ['192.168.0.1'], multi=True)
+    follower = StrOption('follower', "Follower", multi=True)
+    if with_mandatory:
+        properties = ('mandatory',)
+    else:
+        properties = None
+    follower_submulti = StrOption('follower_submulti', "Follower submulti", multi=submulti, properties=properties)
+    follower_integer = IntOption('follower_integer', "Follower integer", multi=True)
+    follower_boolean = BoolOption('follower_boolean', "Follower boolean", multi=True)
+    follower_choice = ChoiceOption('follower_choice', "Follower choice", ('opt1', 'opt2'), multi=True)
+    opt_list = [leader, follower, follower_submulti, follower_integer, follower_boolean, follower_choice]
+    if with_mandatory:
+        opt_list.append(StrOption('follower_mandatory', "Follower mandatory", multi=True, properties=('mandatory',)))
+    leadership = Leadership('leader', 'leader', opt_list)
+    config = Config(OptionDescription('root', 'root', [leadership]))
+    if json == 'tiramisu':
+        return config
+    jconfig = JsonConfig(config.option.dict())
+    return jconfig
+
+
+@pytest.fixture(params=params)
+def json(request):
+    return request.param
+
+
+def test_leadership_help(json):
+    output = """usage: prog.py [-h] [--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
+
+optional arguments:
+  -h, --help            show this help message and exit
+
+leader:
+  leader
+
+  --leader.leader [LEADER [LEADER ...]]
+                        Leader var
+  --leader.pop-leader INDEX
+  --leader.follower INDEX [FOLLOWER]
+                        Follower
+  --leader.follower_submulti INDEX [FOLLOWER_SUBMULTI ...]
+                        Follower submulti
+  --leader.follower_integer INDEX [FOLLOWER_INTEGER]
+                        Follower integer
+  --leader.follower_boolean INDEX
+                        Follower boolean
+  --leader.no-follower_boolean INDEX
+  --leader.follower_choice INDEX [{opt1,opt2}]
+                        Follower choice
+  --leader.follower_mandatory INDEX FOLLOWER_MANDATORY
+                        Follower mandatory
+"""
+    parser = TiramisuCmdlineParser(get_config(json, with_mandatory=True), 'prog.py')
+    f = StringIO()
+    with redirect_stdout(f):
+        parser.print_help()
+    assert f.getvalue() == output
+
+
+def test_leadership_modif_leader(json):
+    output = {'leader.leader': ['192.168.1.1'],
+              'leader.follower': [None],
+              'leader.follower_boolean': [None],
+              'leader.follower_choice': [None],
+              'leader.follower_integer': [None],
+              'leader.follower_submulti': [[]]}
+
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['--leader.leader', '192.168.1.1'])
+    assert config.value.dict() == output
+
+
+def test_leadership_modif_follower(json):
+    output = {'leader.leader': ['192.168.0.1'],
+              'leader.follower': ['255.255.255.0'],
+              'leader.follower_boolean': [None],
+              'leader.follower_choice': [None],
+              'leader.follower_integer': [None],
+              'leader.follower_submulti': [[]]}
+
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['--leader.follower', '0', '255.255.255.0'])
+    assert config.value.dict() == output
+
+
+def test_leadership_modif_follower_not_submulti(json):
+    output = """usage: prog.py [-h] [--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}]]
+prog.py: error: unrecognized arguments: 255.255.255.0
+"""
+
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['--leader.follower', '0', '255.255.255.0', '255.255.255.0'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+def test_leadership_modif_follower_submulti(json):
+    output = {'leader.leader': ['192.168.0.1'],
+              'leader.follower': [None],
+              'leader.follower_boolean': [None],
+              'leader.follower_choice': [None],
+              'leader.follower_integer': [None],
+              'leader.follower_submulti': [['255.255.255.0']]}
+
+    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
+
+
+def test_leadership_modif_follower_submulti_multi(json):
+    output = {'leader.leader': ['192.168.0.1'],
+              'leader.follower': [None],
+              'leader.follower_boolean': [None],
+              'leader.follower_choice': [None],
+              'leader.follower_integer': [None],
+              'leader.follower_submulti': [['255.255.255.0', '255.255.255.128']]}
+
+    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
+
+
+def test_leadership_modif_follower_bool_true(json):
+    output = {'leader.leader': ['192.168.0.1'],
+              'leader.follower': [None],
+              'leader.follower_boolean': [True],
+              'leader.follower_choice': [None],
+              'leader.follower_integer': [None],
+              'leader.follower_submulti': [[]]}
+
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['--leader.follower_boolean', '0'])
+    assert config.value.dict() == output
+
+
+def test_leadership_modif_follower_bool_false(json):
+    output = {'leader.leader': ['192.168.0.1'],
+              'leader.follower': [None],
+              'leader.follower_boolean': [False],
+              'leader.follower_choice': [None],
+              'leader.follower_integer': [None],
+              'leader.follower_submulti': [[]]}
+
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['--leader.no-follower_boolean', '0'])
+    assert config.value.dict() == output
+
+
+def test_leadership_modif_follower_bool_true_fullname(json):
+    output = {'leader.leader': ['192.168.0.1'],
+              'leader.follower': [None],
+              'leader.follower_boolean': [True],
+              'leader.follower_choice': [None],
+              'leader.follower_integer': [None],
+              'leader.follower_submulti': [[]]}
+
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py', fullpath=False)
+    parser.parse_args(['--follower_boolean', '0'])
+    assert config.value.dict() == output
+
+
+def test_leadership_modif_follower_bool_false_fullname(json):
+    output = {'leader.leader': ['192.168.0.1'],
+              'leader.follower': [None],
+              'leader.follower_boolean': [False],
+              'leader.follower_choice': [None],
+              'leader.follower_integer': [None],
+              'leader.follower_submulti': [[]]}
+
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py', fullpath=False)
+    parser.parse_args(['--no-follower_boolean', '0'])
+    assert config.value.dict() == output
+
+
+def test_leadership_modif_follower_choice(json):
+    output = {'leader.leader': ['192.168.0.1'],
+              'leader.follower': [None],
+              'leader.follower_boolean': [None],
+              'leader.follower_choice': ['opt1'],
+              'leader.follower_integer': [None],
+              'leader.follower_submulti': [[]]}
+
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['--leader.follower_choice', '0', 'opt1'])
+    assert config.value.dict() == output
+
+
+def test_leadership_modif_follower_choice_unknown(json):
+    output = """usage: prog.py [-h] [--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}]]
+prog.py: error: argument --leader.follower_choice: invalid choice: 'opt_unknown' (choose from 'opt1', 'opt2')
+"""
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['--leader.follower_choice', '0', 'opt_unknown'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+def test_leadership_modif_follower_not_number(json):
+    output = """usage: prog.py [-h] [--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}]]
+prog.py: error: index must be a number, not a
+"""
+
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['--leader.follower', 'a', '255.255.255.0'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+def test_leadership_modif_multi(json):
+    output = {'leader.leader': ['192.168.1.1', '10.253.10.1', '192.168.253.1'],
+              'leader.follower': ['255.255.255.128', None, '255.255.255.0'],
+              'leader.follower_boolean': [None, None, None],
+              'leader.follower_choice': [None, None, None],
+              'leader.follower_integer': [None, None, None],
+              'leader.follower_submulti': [[], [], []]}
+
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    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
+
+
+def test_leadership_modif_multi_reduce(json):
+    output = {'leader.leader': ['192.168.1.1', '192.168.253.1'],
+              'leader.follower': ['255.255.255.128', '255.255.255.0'],
+              'leader.follower_boolean': [None,  None],
+              'leader.follower_choice': [None, None],
+              'leader.follower_integer': [None, None],
+              'leader.follower_submulti': [[], []]}
+
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    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',
+                       '--leader.pop-leader', '1'])
+    assert config.value.dict() == output
+
+
+def test_leadership_modif_mandatory(json):
+    output = {'leader.leader': ['192.168.1.1'],
+              'leader.follower': [None],
+              'leader.follower_mandatory': ['255.255.255.128'],
+              'leader.follower_boolean': [None],
+              '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.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')
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['--leader.leader', '192.168.1.1'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output2 + ', --leader.follower_mandatory\n'
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['--leader.leader', '192.168.1.1',
+                               '--leader.follower_mandatory', '0', '255.255.255.128'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output2 + '\n'
+    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
+
+
+def test_leadership_modif_mandatory_remove(json):
+    output = {'leader.leader': ['192.168.1.1'],
+              'leader.follower': [None],
+              'leader.follower_mandatory': ['255.255.255.128'],
+              'leader.follower_boolean': [None],
+              '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]
+                                             [--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)
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['--leader.leader', '192.168.1.1'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output2 + ', --leader.follower_mandatory\n'
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['--leader.leader', '192.168.1.1',
+                               '--leader.follower_mandatory', '0', '255.255.255.128'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output2 + '\n'
+    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
+
+
+def test_leadership_modif_mandatory_unvalidate(json):
+    output = {'leader.leader': ['192.168.1.1'],
+              'leader.follower': [None],
+              'leader.follower_mandatory': [None],
+              'leader.follower_boolean': [None],
+              'leader.follower_choice': [None],
+              'leader.follower_integer': [None],
+              'leader.follower_submulti': [[]]}
+    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

tests/test_optiondescription.py

@@ -0,0 +1,193 @@
+from io import StringIO
+from contextlib import redirect_stdout, redirect_stderr
+import pytest
+
+
+from tiramisu_cmdline_parser import TiramisuCmdlineParser
+from tiramisu import IntOption, StrOption, BoolOption, ChoiceOption, \
+                     SymLinkOption, OptionDescription, Config
+try:
+    from tiramisu_api import Config as JsonConfig
+    params = ['tiramisu', 'tiramisu-json']
+except:
+    params = ['tiramisu']
+
+
+def get_config(json, has_tree=False, default_verbosity=False, add_long=False, add_store_false=False, empty_optiondescription=False):
+    choiceoption = ChoiceOption('cmd',
+                                'choice the sub argument',
+                                ('str', 'list', 'int', 'none'),
+                                properties=('mandatory',
+                                            'positional'))
+    booloption = BoolOption('verbosity',
+                            'increase output verbosity',
+                            default=default_verbosity)
+    short_booloption = SymLinkOption('v', booloption)
+
+    od0 = OptionDescription('od0',
+                            'Sub-Tree 1',
+                            [choiceoption,
+                            booloption,
+                            short_booloption,
+                            ])
+    if empty_optiondescription:
+        descr = None
+    else:
+        descr = 'First OptionDescription'
+    od1 = OptionDescription('od1',
+                            descr,
+                            [od0])
+    before = StrOption('before',
+                       'Before',
+                       properties=('mandatory',))
+    after = StrOption('after',
+                      'After',
+                      properties=('mandatory',))
+    str_ = StrOption('str',
+                     'string option 2',
+                     properties=('mandatory',))
+    subtree = OptionDescription('subtree',
+                                'Sub-Tree 2',
+                                [str_])
+    od2 = OptionDescription('od2',
+                            None,
+                            [before, subtree, after])
+    root = OptionDescription('root',
+                             'root',
+                             [od1, od2])
+    config = Config(root)
+    config.property.read_write()
+    if json == 'tiramisu':
+        return config
+    jconfig = JsonConfig(config.option.dict())
+    return jconfig
+
+
+@pytest.fixture(params=params)
+def json(request):
+    return request.param
+
+
+def test_optiondescription_help(json):
+    output = """usage: prog.py [-h] [-v] [-nv] --od2.subtree.str STR --od2.before BEFORE
+               --od2.after AFTER
+               {str,list,int,none}
+
+optional arguments:
+  -h, --help            show this help message and exit
+
+od1:
+  First OptionDescription
+
+od1.od0:
+  Sub-Tree 1
+
+  {str,list,int,none}   choice the sub argument
+  -v, --od1.od0.verbosity
+                        increase output verbosity
+  -nv, --od1.od0.no-verbosity
+
+od2:
+  --od2.before BEFORE   Before
+  --od2.after AFTER     After
+
+od2.subtree:
+  Sub-Tree 2
+
+  --od2.subtree.str STR
+                        string option 2
+"""
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py')
+    f = StringIO()
+    with redirect_stdout(f):
+        parser.print_help()
+    assert f.getvalue() == output
+
+
+def test_optiondescription_help_remove_empty_od(json):
+    output = """usage: prog.py [-h] [-v] [-nv] --od2.subtree.str STR --od2.before BEFORE
+               --od2.after AFTER
+               {str,list,int,none}
+
+optional arguments:
+  -h, --help            show this help message and exit
+
+od1.od0:
+  Sub-Tree 1
+
+  {str,list,int,none}   choice the sub argument
+  -v, --od1.od0.verbosity
+                        increase output verbosity
+  -nv, --od1.od0.no-verbosity
+
+od2:
+  --od2.before BEFORE   Before
+  --od2.after AFTER     After
+
+od2.subtree:
+  Sub-Tree 2
+
+  --od2.subtree.str STR
+                        string option 2
+"""
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', remove_empty_od=True)
+    f = StringIO()
+    with redirect_stdout(f):
+        parser.print_help()
+    assert f.getvalue() == output
+
+
+def test_optiondescription_help_remove_empty_description_od(json):
+    output = """usage: prog.py [-h] [-v] [-nv] --od2.subtree.str STR --od2.before BEFORE
+               --od2.after AFTER
+               {str,list,int,none}
+
+optional arguments:
+  -h, --help            show this help message and exit
+
+od1.od0:
+  Sub-Tree 1
+
+  {str,list,int,none}   choice the sub argument
+  -v, --od1.od0.verbosity
+                        increase output verbosity
+  -nv, --od1.od0.no-verbosity
+
+od2:
+  --od2.before BEFORE   Before
+  --od2.after AFTER     After
+
+od2.subtree:
+  Sub-Tree 2
+
+  --od2.subtree.str STR
+                        string option 2
+"""
+    parser = TiramisuCmdlineParser(get_config(json, empty_optiondescription=True), 'prog.py')
+    f = StringIO()
+    with redirect_stdout(f):
+        parser.print_help()
+    assert f.getvalue() == output
+
+
+def test_optiondescription_help_subtree(json):
+    output = """usage: prog.py [-h] --od2.subtree.str STR --od2.before BEFORE --od2.after
+               AFTER
+
+optional arguments:
+  -h, --help            show this help message and exit
+  --od2.before BEFORE   Before
+  --od2.after AFTER     After
+
+od2.subtree:
+  Sub-Tree 2
+
+  --od2.subtree.str STR
+                        string option 2
+"""
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py', root='od2')
+    f = StringIO()
+    with redirect_stdout(f):
+        parser.print_help()
+    assert f.getvalue() == output

tests/test_readme.py

@@ -0,0 +1,894 @@
+from io import StringIO
+from contextlib import redirect_stdout, redirect_stderr
+import pytest
+
+
+from tiramisu_cmdline_parser import TiramisuCmdlineParser
+from tiramisu import IntOption, StrOption, BoolOption, ChoiceOption, \
+                     SymLinkOption, OptionDescription, Config
+try:
+    from tiramisu_api import Config as JsonConfig
+    params = ['tiramisu', 'tiramisu-json']
+except:
+    params = ['tiramisu']
+
+
+def get_config(json, has_tree=False, default_verbosity=False, add_long=False, add_store_false=False):
+    choiceoption = ChoiceOption('cmd',
+                                'choice the sub argument',
+                                ('str', 'list', 'int', 'none'),
+                                properties=('mandatory',
+                                            'positional'))
+    booloption = BoolOption('verbosity',
+                            'increase output verbosity',
+                            default=default_verbosity)
+    short_booloption = SymLinkOption('v', booloption)
+    str_ = StrOption('str',
+                     'string option',
+                     properties=('mandatory',),
+                     requires=[{'option': choiceoption,
+                                'expected': 'str',
+                                'action': 'disabled',
+                                'inverse': True}])
+    list_ = StrOption('list',
+                      'list string option',
+                      multi=True,
+                      properties=('mandatory',),
+                      requires=[{'option': choiceoption,
+                                 'expected': 'list',
+                                 'action': 'disabled',
+                                 'inverse': True}])
+    int_ = IntOption('int',
+                     'int option',
+                     properties=('mandatory',),
+                     requires=[{'option': choiceoption,
+                                'expected': 'int',
+                                'action': 'disabled',
+                                'inverse': True}])
+
+    root = OptionDescription('root',
+                             'root',
+                             [choiceoption,
+                             booloption,
+                             short_booloption,
+                             str_,
+                             list_,
+                             int_
+                             ])
+    if has_tree:
+        root = OptionDescription('root',
+                                 'root',
+                                 [root])
+    config = Config(root)
+    config.property.read_write()
+    if add_store_false:
+        config.option('verbosity').property.add('storefalse')
+    if add_long:
+        config.option('verbosity').property.add('longargument')
+    if json == 'tiramisu':
+        return config
+    jconfig = JsonConfig(config.option.dict())
+    return jconfig
+
+
+@pytest.fixture(params=params)
+def json(request):
+    return request.param
+
+
+def test_readme_help(json):
+    output = """usage: prog.py [-h] [-v] [-nv] {str,list,int,none}
+
+positional arguments:
+  {str,list,int,none}  choice the sub argument
+
+optional arguments:
+  -h, --help           show this help message and exit
+  -v, --verbosity      increase output verbosity
+  -nv, --no-verbosity
+"""
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py')
+    f = StringIO()
+    with redirect_stdout(f):
+        parser.print_help()
+    assert f.getvalue() == output
+
+
+def test_readme_help_tree(json):
+    output = """usage: prog.py [-h] [-v] [-nv] {str,list,int,none}
+
+optional arguments:
+  -h, --help            show this help message and exit
+
+root:
+  root
+
+  {str,list,int,none}   choice the sub argument
+  -v, --root.verbosity  increase output verbosity
+  -nv, --root.no-verbosity
+"""
+    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py')
+    f = StringIO()
+    with redirect_stdout(f):
+        parser.print_help()
+    assert f.getvalue() == output
+
+
+def test_readme_help_tree_flatten(json):
+    output = """usage: prog.py [-h] [-v] [-nv] {str,list,int,none}
+
+optional arguments:
+  -h, --help           show this help message and exit
+
+root:
+  root
+
+  {str,list,int,none}  choice the sub argument
+  -v, --verbosity      increase output verbosity
+  -nv, --no-verbosity
+"""
+    parser = TiramisuCmdlineParser(get_config(json, True), 'prog.py', fullpath=False)
+    f = StringIO()
+    with redirect_stdout(f):
+        parser.print_help()
+    assert f.getvalue() == output
+
+
+def test_readme_help_modif_positional(json):
+    output = """usage: prog.py "str" [-h] [-v] [-nv] --str STR {str,list,int,none}
+
+positional arguments:
+  {str,list,int,none}  choice the sub argument
+
+optional arguments:
+  -h, --help           show this help message and exit
+  -v, --verbosity      increase output verbosity
+  -nv, --no-verbosity
+  --str STR            string option
+"""
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py')
+    f = StringIO()
+    with redirect_stdout(f):
+        try:
+            parser.parse_args(['str', '--help'])
+        except SystemExit as err:
+            assert str(err) == "0"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+def test_readme_help_modif_positional_remove(json):
+    output = """usage: prog.py "str" [-h] [-v] [-nv] --str STR
+
+optional arguments:
+  -h, --help           show this help message and exit
+  -v, --verbosity      increase output verbosity
+  -nv, --no-verbosity
+  --str STR            string option
+"""
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', display_modified_value=False)
+    f = StringIO()
+    with redirect_stdout(f):
+        try:
+            parser.parse_args(['str', '--help'])
+        except SystemExit as err:
+            assert str(err) == "0"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+def test_readme_help_modif(json):
+    output = """usage: prog.py "str" --str "toto" [-h] [-v] [-nv] --str STR
+                                  {str,list,int,none}
+
+positional arguments:
+  {str,list,int,none}  choice the sub argument
+
+optional arguments:
+  -h, --help           show this help message and exit
+  -v, --verbosity      increase output verbosity
+  -nv, --no-verbosity
+  --str STR            string option
+"""
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py')
+    f = StringIO()
+    with redirect_stdout(f):
+        try:
+            parser.parse_args(['str', '--str', 'toto', '--help'])
+        except SystemExit as err:
+            assert str(err) == "0"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+def test_readme_help_modif_remove(json):
+    output = """usage: prog.py "str" --str "toto" [-h] [-v] [-nv]
+
+optional arguments:
+  -h, --help           show this help message and exit
+  -v, --verbosity      increase output verbosity
+  -nv, --no-verbosity
+"""
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', display_modified_value=False)
+    f = StringIO()
+    with redirect_stdout(f):
+        try:
+            parser.parse_args(['str', '--str', 'toto', '--help'])
+        except SystemExit as err:
+            assert str(err) == "0"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+def test_readme_help_modif_short(json):
+    output = """usage: prog.py "str" -v [-h] [-v] [-nv] --str STR {str,list,int,none}
+
+positional arguments:
+  {str,list,int,none}  choice the sub argument
+
+optional arguments:
+  -h, --help           show this help message and exit
+  -v, --verbosity      increase output verbosity
+  -nv, --no-verbosity
+  --str STR            string option
+"""
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py')
+    f = StringIO()
+    with redirect_stdout(f):
+        try:
+            parser.parse_args(['str', '-v', '--help'])
+        except SystemExit as err:
+            assert str(err) == "0"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+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:
+  -h, --help           show this help message and exit
+  -nv, --no-verbosity  increase output verbosity
+  --str STR            string option
+"""
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', display_modified_value=False)
+    f = StringIO()
+    with redirect_stdout(f):
+        try:
+            parser.parse_args(['str', '-v', '--help'])
+        except SystemExit as err:
+            assert str(err) == "0"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+def test_readme_help_modif_short_no1(json):
+    output = """usage: prog.py "str" -v [-h] [-v] [-nv] --str STR {str,list,int,none}
+
+positional arguments:
+  {str,list,int,none}  choice the sub argument
+
+optional arguments:
+  -h, --help           show this help message and exit
+  -v, --verbosity      increase output verbosity
+  -nv, --no-verbosity
+  --str STR            string option
+"""
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py')
+    f = StringIO()
+    with redirect_stdout(f):
+        try:
+            parser.parse_args(['str', '-nv', '--help'])
+        except SystemExit as err:
+            assert str(err) == "0"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+def test_readme_help_modif_short_no_remove(json):
+    output = """usage: prog.py "str" -v [-h] [-v] --str STR
+
+optional arguments:
+  -h, --help       show this help message and exit
+  -v, --verbosity  increase output verbosity
+  --str STR        string option
+"""
+    parser = TiramisuCmdlineParser(get_config(json), 'prog.py', display_modified_value=False)
+    f = StringIO()
+    with redirect_stdout(f):
+        try:
+            parser.parse_args(['str', '-nv', '--help'])
+        except SystemExit as err:
+            assert str(err) == "0"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+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')
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args([])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+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')
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args([])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+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)
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args([])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+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')
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['str'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+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)
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['str'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+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')
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['str'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+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)
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['str'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+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)
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['str'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+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)
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['str'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+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')
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['none', '--int', '1'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+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)
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['none', '--int', '1'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+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')
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['none', '--root.int', '1'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+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)
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['none', '--root.int', '1'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+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)
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['none', '--int', '1'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+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)
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['none', '--int', '1'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+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)
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['unknown'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+
+
+def test_readme_int(json):
+    output = {'cmd': 'int',
+              'int': 3,
+              'verbosity': False,
+              'v': False}
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['int', '--int', '3'])
+    assert config.value.dict() == output
+
+
+def test_readme_int_tree(json):
+    output = {'root.cmd': 'int',
+              'root.int': 3,
+              'root.verbosity': False,
+              'root.v': False}
+    config = get_config(json, True)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['int', '--root.int', '3'])
+    assert config.value.dict() == output
+
+
+def test_readme_int_tree_flatten(json):
+    output = {'root.cmd': 'int',
+              'root.int': 3,
+              'root.verbosity': False,
+              'root.v': False}
+    config = get_config(json, True)
+    parser = TiramisuCmdlineParser(config, 'prog.py', fullpath=False)
+    parser.parse_args(['int', '--int', '3'])
+    assert config.value.dict() == output
+
+
+def test_readme_int_verbosity(json):
+    output = {'cmd': 'int',
+              'int': 3,
+              'verbosity': True,
+              'v': True}
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['int', '--int', '3', '--verbosity'])
+    assert config.value.dict() == output
+
+
+def test_readme_int_verbosity_tree(json):
+    output = {'root.cmd': 'int',
+              'root.int': 3,
+              'root.verbosity': True,
+              'root.v': True}
+    config = get_config(json, True)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['int', '--root.int', '3', '--root.verbosity'])
+    assert config.value.dict() == output
+
+
+def test_readme_int_verbosity_tree_flatten(json):
+    output = {'root.cmd': 'int',
+              'root.int': 3,
+              'root.verbosity': True,
+              'root.v': True}
+    config = get_config(json, True)
+    parser = TiramisuCmdlineParser(config, 'prog.py', fullpath=False)
+    parser.parse_args(['int', '--int', '3', '--verbosity'])
+    assert config.value.dict() == output
+
+
+def test_readme_int_verbosity_short(json):
+    output = {'cmd': 'int',
+              'int': 3,
+              'verbosity': True,
+              'v': True}
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['int', '--int', '3', '-v'])
+    assert config.value.dict() == output
+
+
+def test_readme_int_verbosity_short_store_false(json):
+    output = {'cmd': 'int',
+              'int': 3,
+              'verbosity': None,
+              'v': True}
+    config = get_config(json, default_verbosity=None, add_store_false=True)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['int', '--int', '3', '-v'])
+    output = {'cmd': 'int',
+              'int': 3,
+              'verbosity': False,
+              'v': False}
+    assert config.value.dict() == output
+    parser.parse_args(['int', '--int', '3', '-nv'])
+    output = {'cmd': 'int',
+              'int': 3,
+              'verbosity': True,
+              'v': True}
+    assert config.value.dict() == output
+
+
+def test_readme_int_verbosity_short_no(json):
+    output = {'cmd': 'int',
+              'int': 3,
+              'verbosity': False,
+              'v': False}
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['int', '--int', '3', '-nv'])
+    assert config.value.dict() == output
+
+
+def test_readme_int_verbosity_short_tree(json):
+    output = {'root.cmd': 'int',
+              'root.int': 3,
+              'root.verbosity': True,
+              'root.v': True}
+    config = get_config(json, True)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['int', '--root.int', '3', '-v'])
+    assert config.value.dict() == output
+
+
+def test_readme_int_verbosity_short_tree_flatten(json):
+    output = {'root.cmd': 'int',
+              'root.int': 3,
+              'root.verbosity': True,
+              'root.v': True}
+    config = get_config(json, True)
+    parser = TiramisuCmdlineParser(config, 'prog.py', fullpath=False)
+    parser.parse_args(['int', '--int', '3', '-v'])
+    assert config.value.dict() == output
+
+
+def test_readme_int_verbosity_short_and_not(json):
+    output = {'cmd': 'int',
+              'int': 3,
+              'verbosity': False,
+              'v': False}
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['int', '--int', '3', '-v', '-nv'])
+    assert config.value.dict() == output
+
+
+def test_readme_str(json):
+    output = {'cmd': 'str',
+              'str': 'value',
+              'verbosity': False,
+              'v': False}
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['str', '--str', 'value'])
+    assert config.value.dict() == output
+
+
+def test_readme_str_tree(json):
+    output = {'root.cmd': 'str',
+              'root.str': 'value',
+              'root.verbosity': False,
+              'root.v': False}
+    config = get_config(json, True)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['str', '--root.str', 'value'])
+    assert config.value.dict() == output
+
+
+def test_readme_str_tree_flatten(json):
+    output = {'root.cmd': 'str',
+              'root.str': 'value',
+              'root.verbosity': False,
+              'root.v': False}
+    config = get_config(json, True)
+    parser = TiramisuCmdlineParser(config, 'prog.py', fullpath=False)
+    parser.parse_args(['str', '--str', 'value'])
+    assert config.value.dict() == output
+
+
+def test_readme_str_int(json):
+    output = {'cmd': 'str',
+              'str': '3',
+              'verbosity': False,
+              'v': False}
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['str', '--str', '3'])
+    assert config.value.dict() == output
+
+
+def test_readme_str_int_tree(json):
+    output = {'root.cmd': 'str',
+              'root.str': '3',
+              'root.verbosity': False,
+              'root.v': False}
+    config = get_config(json, True)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['str', '--root.str', '3'])
+    assert config.value.dict() == output
+
+
+def test_readme_str_int_tree_flatten(json):
+    output = {'root.cmd': 'str',
+              'root.str': '3',
+              'root.verbosity': False,
+              'root.v': False}
+    config = get_config(json, True)
+    parser = TiramisuCmdlineParser(config, 'prog.py', fullpath=False)
+    parser.parse_args(['str', '--str', '3'])
+    assert config.value.dict() == output
+
+
+def test_readme_list_single(json):
+    output = {'cmd': 'list',
+              'list': ['a'],
+              'verbosity': False,
+              'v': False}
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['list', '--list', 'a'])
+    assert config.value.dict() == output
+
+
+def test_readme_list(json):
+    output = {'cmd': 'list',
+              'list': ['a', 'b', 'c'],
+              'verbosity': False,
+              'v': False}
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['list', '--list', 'a', 'b', 'c'])
+    assert config.value.dict() == output
+
+
+def test_readme_list_tree(json):
+    output = {'root.cmd': 'list',
+              'root.list': ['a', 'b', 'c'],
+              'root.verbosity': False,
+              'root.v': False}
+    config = get_config(json, True)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['list', '--root.list', 'a', 'b', 'c'])
+    assert config.value.dict() == output
+
+
+def test_readme_list_tree_flatten(json):
+    output = {'root.cmd': 'list',
+              'root.list': ['a', 'b', 'c'],
+              'root.verbosity': False,
+              'root.v': False}
+    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
+
+
+def test_readme_list_uniq(json):
+    output = {'cmd': 'list',
+              'list': ['a'],
+              'verbosity': False,
+              'v': False}
+    config = get_config(json)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['list', '--list', 'a'])
+    assert config.value.dict() == output
+
+
+def test_readme_list_uniq_tree(json):
+    output = {'root.cmd': 'list',
+              'root.list': ['a'],
+              'root.verbosity': False,
+              'root.v': False}
+    config = get_config(json, True)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['list', '--root.list', 'a'])
+    assert config.value.dict() == output
+
+
+def test_readme_list_uniq_tree_flatten(json):
+    output = {'root.cmd': 'list',
+              'root.list': ['a'],
+              'root.verbosity': False,
+              'root.v': False}
+    config = get_config(json, True)
+    parser = TiramisuCmdlineParser(config, 'prog.py', fullpath=False)
+    parser.parse_args(['list', '--list', 'a'])
+    assert config.value.dict() == output
+
+
+def test_readme_longargument(json):
+    output = {'cmd': 'list',
+              'list': ['a'],
+              'verbosity': True,
+              'v': True}
+    config = get_config(json, add_long=True)
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['list', '--list', 'a', '--v'])
+    assert config.value.dict() == output
+
+
+def test_readme_unknown_key(json):
+    output1 = """usage: prog.py [-h] [-v] [-nv] {str,list,int,none}
+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)
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['--unknown'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output1
+
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args(['--root.unknown'])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output2

tests/test_shortarg.py

@@ -0,0 +1,208 @@
+from io import StringIO
+import pytest
+from contextlib import redirect_stderr
+
+
+from tiramisu_cmdline_parser import TiramisuCmdlineParser
+from tiramisu import IntOption, StrOption, BoolOption, ChoiceOption, \
+                     SymLinkOption, OptionDescription, Config
+try:
+    from tiramisu_api import Config as JsonConfig
+    params = ['tiramisu', 'tiramisu-json']
+except:
+    params = ['tiramisu']
+
+
+@pytest.fixture(params=params)
+def json(request):
+    return request.param
+
+
+def test_short(json):
+    def get_config():
+        list_ = StrOption('list',
+                          'list string option')
+        slist_ = SymLinkOption('l', list_)
+        root = OptionDescription('root',
+                                 'root',
+                                 [list_,
+                                  slist_,
+                                  ])
+        config = Config(root)
+        config.property.read_write()
+        if json != 'tiramisu':
+            config = JsonConfig(config.option.dict())
+        return config
+    #
+    output = {'list': None, 'l': None}
+    config = get_config()
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args([])
+    assert config.value.dict() == output
+    #
+    output = {'list': 'a', 'l': 'a'}
+    config = get_config()
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['--list', 'a'])
+    assert config.value.dict() == 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 config.option('list').value.get() == config.option('l').value.get()
+    assert config.option('list').owner.get() == config.option('l').owner.get()
+    assert config.option('list').owner.isdefault() == config.option('l').owner.isdefault()
+
+
+def test_short_mandatory(json):
+    def get_config():
+        list_ = StrOption('list',
+                          'list string option',
+                          properties=('mandatory',))
+        slist_ = SymLinkOption('l', list_)
+        root = OptionDescription('root',
+                                 'root',
+                                 [list_,
+                                  slist_,
+                                  ])
+        config = Config(root)
+        config.property.read_write()
+        if json != 'tiramisu':
+            config = JsonConfig(config.option.dict())
+        return config
+    #
+    output = """usage: prog.py [-h] -l LIST
+prog.py: error: the following arguments are required: --list
+"""
+    config = get_config()
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args([])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+    #
+    output = {'list': 'a', 'l': 'a'}
+    config = get_config()
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['--list', 'a'])
+    assert config.value.dict() == output
+    #
+    output = {'list': 'a', 'l': 'a'}
+    config = get_config()
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['-l', 'a'])
+    assert config.value.dict() == output
+
+
+def test_short_multi(json):
+    def get_config():
+        list_ = StrOption('list',
+                          'list string option',
+                          multi=True)
+        slist_ = SymLinkOption('l', list_)
+        root = OptionDescription('root',
+                                 'root',
+                                 [list_,
+                                  slist_,
+                                  ])
+        config = Config(root)
+        config.property.read_write()
+        if json != 'tiramisu':
+            config = JsonConfig(config.option.dict())
+        return config
+    #
+    output = {'list': [], 'l': []}
+    config = get_config()
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args([])
+    assert config.value.dict() == output
+    #
+    output = {'list': ['a'], 'l': ['a']}
+    config = get_config()
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['--list', 'a'])
+    assert config.value.dict() == 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
+    #
+    output = {'list': ['a'], 'l': ['a']}
+    config = get_config()
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['-l', 'a'])
+    assert config.value.dict() == 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
+
+
+def test_short_multi_mandatory(json):
+    def get_config():
+        list_ = StrOption('list',
+                          'list string option',
+                          multi=True,
+                          properties=('mandatory',))
+        slist_ = SymLinkOption('l', list_)
+        root = OptionDescription('root',
+                                 'root',
+                                 [list_,
+                                  slist_,
+                                  ])
+        config = Config(root)
+        config.property.read_write()
+        if json != 'tiramisu':
+            config = JsonConfig(config.option.dict())
+        return config
+    #
+    output = """usage: prog.py [-h] -l LIST [LIST ...]
+prog.py: error: the following arguments are required: --list
+"""
+    config = get_config()
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    f = StringIO()
+    with redirect_stderr(f):
+        try:
+            parser.parse_args([])
+        except SystemExit as err:
+            assert str(err) == "2"
+        else:
+            raise Exception('must raises')
+    assert f.getvalue() == output
+    #
+    output = {'list': ['a'], 'l': ['a']}
+    config = get_config()
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['--list', 'a'])
+    assert config.value.dict() == 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
+    #
+    output = {'list': ['a'], 'l': ['a']}
+    config = get_config()
+    parser = TiramisuCmdlineParser(config, 'prog.py')
+    parser.parse_args(['-l', 'a'])
+    assert config.value.dict() == 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

tiramisu_cmdline_parser.py

@@ -1,273 +0,0 @@
-# Copyright (C) 2018 Team tiramisu (see AUTHORS for all contributors)
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU Lesser General Public License as published by the
-# Free Software Foundation, either version 3 of the License, or (at your
-# option) any later version.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
-# details.
-#
-# 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, Optional
-from argparse import ArgumentParser, Namespace, SUPPRESS, _HelpAction
-try:
-    from tiramisu import Config
-    from tiramisu.error import PropertiesOptionError
-except ImportError:
-    Config = None
-    from tiramisu_json_api.error import PropertiesOptionError
-try:
-    from tiramisu_json_api import Config as ConfigJson
-    if Config is None:
-        Config = ConfigJson
-except ImportError:
-    ConfigJson = Config
-
-
-class TiramisuNamespace(Namespace):
-    def _populate(self):
-        #self._config.property.read_only()
-        for tiramisu_key, tiramisu_value in self._config.value.dict().items():
-            option = self._config.option(tiramisu_key)
-            if not option.option.issymlinkoption():
-                if tiramisu_value == [] and option.option.ismulti() and option.owner.isdefault():
-                    tiramisu_value = None
-                super().__setattr__(tiramisu_key, tiramisu_value)
-        #self._config.property.read_write()
-
-    def __init__(self, config):
-        self._config = config
-        super().__init__()
-
-    def __setattr__(self, key, value):
-        if key == '_config':
-            super().__setattr__(key, value)
-            return
-        # self._config.property.read_write()
-        option = self._config.option(key)
-        if option.option.ismulti() and value is not None and not isinstance(value, list):
-            value = [value]
-        option.value.set(value)
-
-    def __getattribute__(self, key):
-        if key == '__dict__' and hasattr(self, '_config'):
-            self._populate()
-        return super().__getattribute__(key)
-
-
-class _TiramisuHelpAction(_HelpAction):
-    needs = False
-    def __call__(self, *args, **kwargs):
-        _TiramisuHelpAction.needs = True
-
-    def display(self, parser):
-        _HelpAction.__call__(self, parser, None, None)
-
-
-class TiramisuCmdlineParser(ArgumentParser):
-    def __init__(self,
-                 config: Union[Config, ConfigJson],
-                 *args,
-                 fullpath: bool=True,
-                 _forhelp: bool=False,
-                 **kwargs):
-        self.fullpath = fullpath
-        self.config = config
-        super().__init__(*args, **kwargs)
-        self.register('action', 'help', _TiramisuHelpAction)
-        self._config_to_argparser(_forhelp,
-                                  self.config.option)
-
-    def _pop_action_class(self, kwargs, default=None):
-        ret = super()._pop_action_class(kwargs, default)
-        if kwargs.get('action') != 'help' and kwargs.get('dest') != 'help':
-            return ret
-        return _TiramisuHelpAction
-
-    def _match_arguments_partial(self,
-                                 actions,
-                                 arg_string_pattern):
-        # used only when check first proposal for first value
-        # we have to remove all actions with propertieserror
-        # so only first settable option will be returned
-        actions_pop = []
-        for idx, action in enumerate(actions):
-            if self.config.option(action.dest).property.get(only_raises=True):
-                actions_pop.append(idx)
-            else:
-                break
-        for idx in actions_pop:
-            actions.pop(0)
-        return super()._match_arguments_partial(actions, arg_string_pattern)
-
-    def _parse_known_args(self, args=None, namespace=None):
-
-        namespace_, args_ = super()._parse_known_args(args, namespace)
-        if args != args_ and args_ and args_[0].startswith(self.prefix_chars):
-            # option that was disabled are no more disable
-            # so create a new parser
-            new_parser = TiramisuCmdlineParser(self.config,
-                                               self.prog,
-                                               fullpath=self.fullpath)
-            namespace_, args_ = new_parser._parse_known_args(args_, namespace)
-        else:
-            if self._registries['action']['help'].needs:
-                # display help only when all variables assignemnt are done
-                self._registries['action']['help'].needs = False
-                helper = self._registries['action']['help'](None)
-                helper.display(self)
-        return namespace_, args_
-
-    def add_argument(self, *args, **kwargs):
-        if args == ('-h', '--help'):
-            super().add_argument(*args, **kwargs)
-        else:
-            raise NotImplementedError('do not use add_argument')
-
-    def add_arguments(self, *args, **kwargs):
-        raise NotImplementedError('do not use add_argument')
-
-    def add_subparsers(self, *args, **kwargs):
-        raise NotImplementedError('do not use add_subparsers')
-
-    def _gen_argument(self, name, properties):
-        if len(name) == 1 and 'longargument' not in properties:
-            return self.prefix_chars + name
-        return self.prefix_chars * 2 + name
-
-    def _config_to_argparser(self,
-                             _forhelp: bool,
-                             config,
-                             prefix: Optional[str]=None,
-                             group=None) -> None:
-        if group is None:
-            group = super()
-        actions = {}
-        for obj in config.list(type='all'):
-            option = obj.option
-            if option.isoptiondescription():
-                if _forhelp:
-                    group = self.add_argument_group(option.doc())
-                if prefix:
-                    prefix_ = prefix + '.' + option.name()
-                else:
-                    prefix_ = option.path()
-                self._config_to_argparser(_forhelp, obj, prefix_, group)
-                continue
-            if 'frozen' in option.properties():
-                continue
-            name = option.name()
-            if name.startswith(self.prefix_chars):
-                raise ValueError('name cannot startswith "{}"'.format(self.prefix_chars))
-            properties = obj.property.get()
-            kwargs = {'help': option.doc().replace('%', '%%')}
-            if 'positional' in properties:
-                #if not 'mandatory' in properties:
-                #    raise ValueError('"positional" argument must be "mandatory" too')
-                args = [option.path()]
-                #if option.requires():
-                kwargs['default'] = obj.value.get()
-                kwargs['nargs'] = '?'
-            else:
-                kwargs['dest'] = option.path()
-                kwargs['default'] = SUPPRESS
-                if self.fullpath and prefix:
-                    name = prefix + '.' + name
-                args = [self._gen_argument(name, properties)]
-                if _forhelp and 'mandatory' in properties:
-                    kwargs['required'] = True
-            if option.type() == 'bool':
-                if 'mandatory' in properties:
-                    raise ValueError('"mandatory" property is not allowed for BoolOption')
-                #if not isinstance(option.default(), bool):
-                #    raise ValueError('default value is mandatory for BoolOption')
-                if obj.value.get() is False:
-                    action = 'store_true'
-                else:
-                    action = 'store_false'
-                kwargs['action'] = action
-            else:
-                if obj.value.get() not in [None, []]:
-                    #kwargs['default'] = kwargs['const'] = option.default()
-                    #kwargs['action'] = 'store_const'
-                    kwargs['nargs'] = '?'
-                if option.ismulti():
-                    if _forhelp and 'mandatory' in properties:
-                        kwargs['nargs'] = '+'
-                    else:
-                        kwargs['nargs'] = '*'
-                if option.type() == 'str':
-                    pass
-                elif option.type() == 'int':
-                    kwargs['type'] = int
-                elif option.issymlinkoption():
-                    actions[option.name(follow_symlink=True)][0].insert(0, args[0])
-                    continue
-                elif option.type() == 'choice':
-                    kwargs['choices'] = obj.value.list()
-                else:
-                    pass
-                    #raise NotImplementedError('not supported yet')
-            actions[option.name()] = (args, kwargs)
-        for args, kwargs in actions.values():
-            group.add_argument(*args, **kwargs)
-
-
-    def parse_args(self,
-                   *args,
-                   valid_mandatory=True,
-                   **kwargs):
-        kwargs['namespace'] = TiramisuNamespace(self.config)
-        try:
-            namespaces = super().parse_args(*args, **kwargs)
-            del namespaces.__dict__['_config']
-        except PropertiesOptionError as err:
-            name = err._option_bag.option.impl_getname()
-            properties = self.config.option(name).property.get()
-            if 'positional' not in properties:
-                if len(name) == 1 and 'longargument' not in properties:
-                    name = self.prefix_chars + name
-                else:
-                    name = self.prefix_chars * 2 + name
-            if err.proptype == ['mandatory']:
-                self.error('the following arguments are required: {}'.format(name))
-            else:
-                self.error('unrecognized arguments: {}'.format(name))
-        if valid_mandatory:
-            for key in self.config.value.mandatory():
-                properties = self.config.option(key).property.get()
-                if 'positional' not in properties:
-                    if self.fullpath or '.' not in key:
-                        name = key
-                    else:
-                        name = key.rsplit('.', 1)[1]
-                    args = self._gen_argument(name, self.config.option(key).property.get())
-                else:
-                    args = key
-                self.error('the following arguments are required: {}'.format(args))
-        return namespaces
-
-    def format_usage(self,
-                     *args,
-                     **kwargs):
-        help_formatter = TiramisuCmdlineParser(self.config,
-                                               self.prog,
-                                               fullpath=self.fullpath,
-                                               _forhelp=True)
-        return super(TiramisuCmdlineParser, help_formatter).format_usage(*args, **kwargs)
-
-    def format_help(self, *args, **kwargs):
-        help_formatter = TiramisuCmdlineParser(self.config,
-                                               self.prog,
-                                               fullpath=self.fullpath,
-                                               _forhelp=True)
-        return super(TiramisuCmdlineParser, help_formatter).format_help(*args, **kwargs)
-
-    def get_config(self):
-        return self.config

tiramisu_cmdline_parser/__init__.py

@@ -0,0 +1,9 @@
+try:
+    from .api import TiramisuCmdlineParser
+except ImportError as err:
+    import warnings
+    warnings.warn("cannot not import TiramisuCmdlineParser {err}", ImportWarning)
+    TiramisuCmdlineParser = None
+
+__version__ = "0.5"
+__all__ = ('TiramisuCmdlineParser',)

tiramisu_cmdline_parser/api.py

@@ -0,0 +1,638 @@
+# Copyright (C) 2018-2019 Team tiramisu (see AUTHORS for all contributors)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or (at your
+# option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
+# details.
+#
+# 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 copy import copy
+from gettext import gettext as _
+
+try:
+    from tiramisu import Config
+    from tiramisu.error import PropertiesOptionError, RequirementError, LeadershipError
+except ImportError:
+    Config = None
+    from tiramisu_api.error import PropertiesOptionError
+    RequirementError = PropertiesOptionError
+    LeadershipError = ValueError
+try:
+    from tiramisu_api import Config as ConfigJson
+    if Config is None:
+        Config = ConfigJson
+except ImportError:
+    ConfigJson = Config
+
+
+def get_choice_list(obj, properties, display):
+    def convert(choice):
+        if isinstance(choice, int):
+            return str(choice)
+        return choice
+    choices = [convert(choice) for choice in obj.value.list()]
+    if choices and choices[0] == '':
+        del choices[0]
+    if display:
+        choices = '{{{}}}'.format(','.join(choices))
+        if 'mandatory' not in properties:
+            choices = '[{}]'.format(choices)
+    return choices
+
+
+class TiramisuNamespace(Namespace):
+    def __init__(self,
+                 config: Config,
+                 root: Optional[str]) -> None:
+        super().__setattr__('_config', config)
+        super().__setattr__('_root', root)
+        super().__setattr__('list_force_no', {})
+        super().__setattr__('list_force_del', {})
+        super().__setattr__('arguments', {})
+        self._populate()
+        super().__init__()
+
+    def _populate(self) -> None:
+        if self._root is None:
+            config = self._config
+        else:
+            config = self._config.option(self._root)
+        for tiramisu_key, tiramisu_value in config.value.dict(fullpath=True).items():
+            option = self._config.option(tiramisu_key)
+            if not option.option.issymlinkoption():
+                if tiramisu_value == [] and \
+                        option.option.ismulti():  # and \
+                        # option.owner.isdefault():
+                    tiramisu_value = None
+                super().__setattr__(tiramisu_key, tiramisu_value)
+
+    def __setattr__(self,
+                    key: str,
+                    value: Any) -> None:
+        if key in self.list_force_no:
+            true_key = self.list_force_no[key]
+        elif key in self.list_force_del:
+            true_key = self.list_force_del[key]
+        else:
+            true_key = key
+        option = self._config.option(true_key)
+        if option.option.isfollower():
+            _setattr = self._setattr_follower
+            true_value = ','.join(value[1:])
+        else:
+            _setattr = self._setattr
+            true_value = value
+        if option.option.type() == 'choice':
+            # HACK if integer in choice
+            values = option.value.list()
+            if isinstance(value, list):
+                int_value = []
+                for val in value:
+                    if isinstance(val, str) and val.isdigit():
+                        int_val = int(val)
+                        if int_val in values:
+                            val = int_val
+                    int_value.append(val)
+                value = int_value
+            elif value not in values and isinstance(value, str) and value.isdigit():
+                int_value = int(value)
+                if int_value in values:
+                    value = int_value
+        try:
+            if key in self.list_force_del:
+                option.value.pop(value)
+            else:
+                _setattr(option, true_key, key, value)
+        except ValueError as err:
+            if option.option.type() == 'choice':
+                values = option.value.list()
+                if isinstance(true_value, list):
+                    for val in value:
+                        if val not in values:
+                            display_value = val
+                            break
+                else:
+                    display_value = true_value
+                choices = get_choice_list(option, option.property.get(), False)
+                raise ValueError("argument {}: invalid choice: '{}' (choose from {})".format(self.arguments[key], display_value, ', '.join([f"'{val}'" for val in choices])))
+            else:
+                raise err
+
+    def _setattr(self,
+                 option: 'Option',
+                 true_key: str,
+                 key: str,
+                 value: Any) -> None:
+        if option.option.ismulti() and \
+                value is not None and \
+                not isinstance(value, list):
+            value = [value]
+        try:
+            option.value.set(value)
+        except PropertiesOptionError:
+            raise AttributeError('unrecognized arguments: {}'.format(self.arguments[key]))
+
+    def _setattr_follower(self,
+                          option: 'Option',
+                          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':
+            value = key not in self.list_force_no
+        elif option.option.issubmulti():
+            value = value[1:]
+        else:
+            value = value[1]
+        self._config.option(true_key, index).value.set(value)
+
+
+class TiramisuHelpFormatter:
+    def _get_default_metavar_for_optional(self,
+                                          action):
+        ret = super()._get_default_metavar_for_optional(action)
+        if '.' in ret:
+            ret = ret.rsplit('.', 1)[1]
+        return ret
+
+    class _Section(HelpFormatter._Section):
+        def format_help(self):
+            # Remove empty OD
+            if self.formatter.remove_empty_od and \
+                    len(self.items) == 1 and \
+                    self.items[0][0].__name__ == '_format_text':
+                return ''
+            return super().format_help()
+
+
+class _TiramisuHelpAction(_HelpAction):
+    needs = False
+    def __call__(self, *args, **kwargs):
+        _TiramisuHelpAction.needs = True
+
+    def display(self, parser):
+        _HelpAction.__call__(self, parser, None, None)
+
+
+class _BuildKwargs:
+    def __init__(self,
+                 name: str,
+                 option: 'Option',
+                 cmdlineparser: 'TiramisuCmdlineParser',
+                 properties: List[str],
+                 force_no: bool,
+                 force_del: bool,
+                 display_modified_value: bool,
+                 not_display: bool) -> None:
+        self.kwargs = {}
+        self.cmdlineparser = cmdlineparser
+        self.properties = properties
+        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()
+            if not description:
+                description = description.replace('%', '%%')
+            self.kwargs['help'] = description
+        if 'positional' not in self.properties:
+            is_short_name = self.cmdlineparser._is_short_name(name, 'longargument' in self.properties)
+            if self.force_no:
+                ga_name = self.gen_argument_name(name, is_short_name)
+                ga_path = self.gen_argument_name(option.path(), is_short_name)
+                self.cmdlineparser.namespace.list_force_no[ga_path] = option.path()
+            elif self.force_del:
+                ga_name = self.gen_argument_name(name, is_short_name)
+                ga_path = self.gen_argument_name(option.path(), is_short_name)
+                self.cmdlineparser.namespace.list_force_del[ga_path] = option.path()
+            else:
+                ga_name = name
+            self.kwargs['dest'] = self.gen_argument_name(option.path(), False)
+            argument = self.cmdlineparser._gen_argument(ga_name, is_short_name)
+            self.cmdlineparser.namespace.arguments[option.path()] = argument
+            self.args = [argument]
+        else:
+            self.cmdlineparser.namespace.arguments[option.path()] = option.path()
+            self.args = [option.path()]
+
+    def __setitem__(self,
+                    key: str,
+                    value: Any) -> None:
+        self.kwargs[key] = value
+
+    def add_argument(self,
+                     option: 'Option'):
+        is_short_name = self.cmdlineparser._is_short_name(option.name(), 'longargument' in self.properties)
+        if self.force_no:
+            name = self.gen_argument_name(option.name(), is_short_name)
+        elif self.force_del:
+            name = self.gen_argument_name(option.name(), is_short_name)
+        else:
+            name = option.name()
+        argument = self.cmdlineparser._gen_argument(name, is_short_name)
+        self.cmdlineparser.namespace.arguments[option.path()] = argument
+        self.args.insert(0, argument)
+
+    def gen_argument_name(self, name, is_short_name):
+        if self.force_no:
+            if is_short_name:
+                prefix = 'n'
+            else:
+                prefix = 'no-'
+            if '.' in name:
+                sname = name.rsplit('.', 1)
+                name = sname[0] + '.' + prefix + sname[1]
+            else:
+                name = prefix + name
+        if self.force_del:
+            if is_short_name:
+                prefix = 'p'
+            else:
+                prefix = 'pop-'
+            if '.' in name:
+                sname = name.rsplit('.', 1)
+                name = sname[0] + '.' + prefix + sname[1]
+            else:
+                name = prefix + name
+        return name
+
+    def get(self) -> Tuple[Dict]:
+        return self.args, self.kwargs
+
+
+class TiramisuCmdlineParser(ArgumentParser):
+    def __init__(self,
+                 config: Union[Config, ConfigJson],
+                 *args,
+                 root: str=None,
+                 fullpath: bool=True,
+                 remove_empty_od: bool=False,
+                 display_modified_value: bool=True,
+                 formatter_class=HelpFormatter,
+                 unrestraint: bool=False,
+                 _forhelp: bool=False,
+                 **kwargs):
+        self.fullpath = fullpath
+        self.config = config
+        self.root = root
+        self.remove_empty_od = remove_empty_od
+        self.unrestraint = unrestraint
+        self.display_modified_value = display_modified_value
+        if TiramisuHelpFormatter not in formatter_class.__mro__:
+            formatter_class = type('TiramisuHelpFormatter', (TiramisuHelpFormatter, formatter_class), {})
+        formatter_class.remove_empty_od = self.remove_empty_od
+        kwargs['formatter_class'] = formatter_class
+        if not _forhelp and self.unrestraint:
+            subconfig = self.config.unrestraint
+        else:
+            subconfig = self.config
+        if self.root is None:
+            subconfig = subconfig.option
+        else:
+            subconfig = subconfig.option(self.root)
+        self.namespace = TiramisuNamespace(self.config, self.root)
+        super().__init__(*args, **kwargs)
+        self.register('action', 'help', _TiramisuHelpAction)
+        self._config_to_argparser(_forhelp,
+                                  subconfig,
+                                  self.root)
+
+    def _pop_action_class(self, kwargs, default=None):
+        ret = super()._pop_action_class(kwargs, default)
+        if kwargs.get('action') != 'help' and kwargs.get('dest') != 'help':
+            return ret
+        return _TiramisuHelpAction
+
+    def _match_arguments_partial(self,
+                                 actions,
+                                 arg_string_pattern):
+        # used only when check first proposal for first value
+        # we have to remove all actions with propertieserror
+        # so only first settable option will be returned
+        actions_pop = []
+        for idx, action in enumerate(actions):
+            if self.config.option(action.dest).property.get(only_raises=True):
+                actions_pop.append(idx)
+            else:
+                break
+        for idx in actions_pop:
+            actions.pop(0)
+        return super()._match_arguments_partial(actions, arg_string_pattern)
+
+    def _is_short_name(self, name, longargument):
+        return len(name) == 1 and not longargument
+
+    def _gen_argument(self, name, is_short_name):
+        if is_short_name:
+            return self.prefix_chars + name
+        return self.prefix_chars * 2 + name
+
+    def _parse_known_args(self, args=None, namespace=None):
+        try:
+            namespace_, args_ = super()._parse_known_args(args, namespace)
+        except (ValueError, LeadershipError, AttributeError) as err:
+            self.error(err)
+        if args != args_ and args_ and args_[0].startswith(self.prefix_chars):
+            # option that was disabled are no more disable
+            # so create a new parser
+            new_parser = TiramisuCmdlineParser(self.config,
+                                               self.prog,
+                                               root=self.root,
+                                               remove_empty_od=self.remove_empty_od,
+                                               display_modified_value=self.display_modified_value,
+                                               formatter_class=self.formatter_class,
+                                               epilog=self.epilog,
+                                               description=self.description,
+                                               unrestraint=self.unrestraint,
+                                               fullpath=self.fullpath)
+            namespace_, args_ = new_parser._parse_known_args(args_, new_parser.namespace)
+        else:
+            if self._registries['action']['help'].needs:
+                # display help only when all variables assignemnt are done
+                self._registries['action']['help'].needs = False
+                helper = self._registries['action']['help'](None)
+                helper.display(self)
+        return namespace_, args_
+
+    def add_argument(self, *args, **kwargs):
+        if args == ('-h', '--help'):
+            super().add_argument(*args, **kwargs)
+        else:
+            raise NotImplementedError(_('do not use add_argument'))
+
+    def add_arguments(self, *args, **kwargs):
+        raise NotImplementedError(_('do not use add_argument'))
+
+    def add_subparsers(self, *args, **kwargs):
+        raise NotImplementedError(_('do not use add_subparsers'))
+
+    def _option_is_not_default(self,
+                               properties,
+                               type,
+                               name,
+                               value):
+        if 'positional' not in properties:
+            is_short_name = self._is_short_name(name, 'longargument' in properties)
+            self.prog += ' {}'.format(self._gen_argument(name, is_short_name))
+        if type != 'boolean':
+            if isinstance(value, list):
+                for val in value:
+                    self.prog += ' "{}"'.format(val)
+            else:
+                self.prog += ' "{}"'.format(value)
+
+    def _config_list(self,
+                     config: Config,
+                     prefix: Optional[str],
+                     _forhelp: bool,
+                     group, level):
+        for obj in config.list(type='all'):
+            # do not display frozen option
+            if 'frozen' in obj.option.properties():
+                continue
+            if obj.option.isoptiondescription():
+                if _forhelp:
+                    newgroup = self.add_argument_group(obj.option.path(), obj.option.description())
+                else:
+                    newgroup = group
+                if prefix:
+                    prefix_ = prefix + '.' + obj.option.name()
+                else:
+                    prefix_ = obj.option.path()
+                self._config_to_argparser(_forhelp, obj, prefix_, newgroup, level + 1)
+            elif obj.option.type() == 'boolean' and not obj.option.issymlinkoption():
+                if not obj.option.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():
+                yield obj, None, False
+                yield obj, None, True
+            else:
+                yield obj, None, None
+
+    def _config_to_argparser(self,
+                             _forhelp: bool,
+                             config,
+                             prefix: Optional[str],
+                             group=None,
+                             level=0) -> None:
+        if group is None:
+            group = super()
+        actions = {}
+        leadership_len = None
+        options_is_not_default = {}
+        for obj, 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)
+                if symlink_name in options_is_not_default:
+                    options_is_not_default[symlink_name]['name'] = name
+                if symlink_name in actions:
+                    for action in actions[symlink_name]:
+                        action.add_argument(option)
+                continue
+            if force_del:
+                value = None
+            elif option.isleader():
+                value = obj.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())
+                except:
+                    value = None
+            else:
+                value = obj.value.get()
+            if self.fullpath and prefix:
+                name = prefix + '.' + name
+            if option.isfollower():
+                properties = obj.option.properties()
+            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}
+                if not self.display_modified_value:
+                    continue
+            if 'positional' in properties:
+                if option.type() == 'boolean':
+                    raise ValueError(_('boolean option must not be positional'))
+                if not 'mandatory' in properties:
+                    raise ValueError('"positional" argument must be "mandatory" too')
+                if _forhelp:
+                    kwargs['default'] = obj.value.default()
+                else:
+                    kwargs['default'] = value
+                    kwargs['nargs'] = '?'
+            else:
+                kwargs['default'] = SUPPRESS
+                if _forhelp and 'mandatory' in properties:
+                    kwargs['required'] = True
+                if not force_del and option.type() == 'boolean':
+                    if not option.isfollower():
+                        if 'storefalse' in properties:
+                            if force_no:
+                                action = 'store_true'
+                            else:
+                                action = 'store_false'
+                        elif force_no:
+                            action = 'store_false'
+                        else:
+                            action = 'store_true'
+                        kwargs['action'] = action
+                    else:
+                        kwargs['metavar'] = 'INDEX'
+            if option.type() != 'boolean' or force_del:
+                if not force_del:
+                    if _forhelp:
+                        value = obj.value.default()
+                    if value not in [None, []]:
+                        #kwargs['default'] = kwargs['const'] = option.default()
+                        #kwargs['action'] = 'store_const'
+                        kwargs['nargs'] = '?'
+
+                    if not option.isfollower() and option.ismulti():
+                        if _forhelp and 'mandatory' in properties:
+                            kwargs['nargs'] = '+'
+                        else:
+                            kwargs['nargs'] = '*'
+                if option.isfollower() and not option.type() == 'boolean':
+                    metavar = option.name().upper()
+                    if option.issubmulti():
+                        kwargs['nargs'] = '+'
+                    else:
+                        kwargs['nargs'] = 2
+                        if _forhelp and 'mandatory' not in properties:
+                            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))
+                    else:
+                        kwargs['metavar'] = ('INDEX', metavar)
+                if force_del:
+                    kwargs['metavar'] = 'INDEX'
+                    kwargs['type'] = int
+                elif option.type() == 'string':
+                    pass
+                elif option.type() == 'integer' or option.type() == 'boolean':
+                    # when boolean we are here only if follower
+                    kwargs['type'] = int
+                    if _forhelp and option.type() == 'boolean':
+                        kwargs['metavar'] = 'INDEX'
+                        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)
+                elif option.type() == 'float':
+                    kwargs['type'] = float
+                else:
+                    pass
+            actions.setdefault(option.name(), []).append(kwargs)
+        for option_is_not_default in options_is_not_default.values():
+            self._option_is_not_default(**option_is_not_default)
+        for values in actions.values():
+            for value in values:
+                args, kwargs = value.get()
+                group.add_argument(*args, **kwargs)
+    def _valid_mandatory(self):
+        pass
+
+    def parse_args(self,
+                   *args,
+                   valid_mandatory=True,
+                   **kwargs):
+        kwargs['namespace'] = self.namespace
+        try:
+            namespaces = super().parse_args(*args, **kwargs)
+        except PropertiesOptionError as err:
+            name = err._option_bag.option.impl_getname()
+            properties = self.config.option(name).property.get()
+            if self.fullpath and 'positional' not in properties:
+                if len(name) == 1 and 'longargument' not in properties:
+                    name = self.prefix_chars + name
+                else:
+                    name = self.prefix_chars * 2 + name
+            if err.proptype == ['mandatory']:
+                self.error('the following arguments are required: {}'.format(name))
+            else:
+                self.error('unrecognized arguments: {}'.format(name))
+        if valid_mandatory:
+            errors = []
+            for key in self.config.value.mandatory():
+                properties = self.config.option(key).option.properties()
+                if not self.config.option(key).option.isfollower():
+                    if 'positional' not in properties:
+                        if self.fullpath or '.' not in key:
+                            name = key
+                        else:
+                            name = key.rsplit('.', 1)[1]
+                        is_short_name = self._is_short_name(name, 'longargument' in self.config.option(key).property.get())
+                        args = self._gen_argument(name, is_short_name)
+                    else:
+                        args = key
+                else:
+                    if 'positional' not in properties:
+                        args = self._gen_argument(key, False)
+                    else:
+                        args = key
+                if not self.fullpath and '.' in args:
+                    args = args.rsplit('.', 1)[1]
+                    if 'positional' not in properties:
+                        args = self._gen_argument(args, False)
+                errors.append(args)
+            if errors:
+                self.error('the following arguments are required: {}'.format(', '.join(errors)))
+        return namespaces
+
+    def format_usage(self,
+                     *args,
+                     **kwargs):
+        help_formatter = TiramisuCmdlineParser(self.config,
+                                               self.prog,
+                                               root=self.root,
+                                               fullpath=self.fullpath,
+                                               remove_empty_od=self.remove_empty_od,
+                                               display_modified_value=self.display_modified_value,
+                                               formatter_class=self.formatter_class,
+                                               epilog=self.epilog,
+                                               description=self.description,
+                                               _forhelp=True)
+        return super(TiramisuCmdlineParser, help_formatter).format_usage(*args, **kwargs)
+
+    def format_help(self):
+        help_formatter = TiramisuCmdlineParser(self.config,
+                                               self.prog,
+                                               root=self.root,
+                                               fullpath=self.fullpath,
+                                               remove_empty_od=self.remove_empty_od,
+                                               display_modified_value=self.display_modified_value,
+                                               formatter_class=self.formatter_class,
+                                               epilog=self.epilog,
+                                               description=self.description,
+                                               _forhelp=True)
+        return super(TiramisuCmdlineParser, help_formatter).format_help()
+
+    def get_config(self):
+        return self.config