release/0.7.0: Refactor ArgumentParser args and groups

nok · nok · commit a879ce21d6b1 · 2018-12-16T18:15:28.000+01:00
diff --git a/readme.md b/readme.md
@@ -221,19 +221,19 @@ You can run and test all notebooks by starting a Jupyter notebook server locally
 
 ```bash
 $ make open.examples
-$ make stop.examples 
+$ make stop.examples
 ```
 
 ## Command-line interface
 
 In general you can use the porter on the command line:
 
 ```
-$ porter --input <PICKLE_FILE> [--output <DEST_DIR>]
-         [--class_name <CLASS_NAME>] [--method_name <METHOD_NAME>]
+$ porter <PICKLE_FILE> [--to <directory>]
+         [--class_name <class_name>] [--method_name <method_name>]
          [--export] [--checksum] [--data] [--pipe]
          [--c] [--java] [--js] [--go] [--php] [--ruby]
-         [--help] [--version]
+         [--version] [--help]
 ```
 
 The following example shows how you can save a trained estimator to the [pickle format](http://scikit-learn.org/stable/modules/model_persistence.html#persistence-example):
@@ -248,29 +248,29 @@ joblib.dump(clf, 'estimator.pkl', compress=0)
 After that the estimator can be transpiled to JavaScript by using the following command:
 
 ```bash
-$ porter -i estimator.pkl --js
+$ porter estimator.pkl --js
 ```
 
 The target programming language is changeable on the fly:
 
 ```bash
-$ porter -i estimator.pkl --c
-$ porter -i estimator.pkl --java
-$ porter -i estimator.pkl --php
-$ porter -i estimator.pkl --java
-$ porter -i estimator.pkl --ruby
+$ porter estimator.pkl --c
+$ porter estimator.pkl --java
+$ porter estimator.pkl --php
+$ porter estimator.pkl --java
+$ porter estimator.pkl --ruby
 ```
 
 For further processing the argument `--pipe` can be used to pass the result:
 
 ```bash
-$ porter -i estimator.pkl --js --pipe > estimator.js
+$ porter estimator.pkl --js --pipe > estimator.js
 ```
 
 For instance the result can be minified by using [UglifyJS](https://github.com/mishoo/UglifyJS2):
 
 ```bash
-$ porter -i estimator.pkl --js --pipe | uglifyjs --compress -o estimator.min.js
+$ porter estimator.pkl --js --pipe | uglifyjs --compress -o estimator.min.js
 ```
 
 
@@ -336,7 +336,7 @@ Independently, the following compilers and intepreters are required to cover all
 The tests cover module functions as well as matching predictions of transpiled estimators. Start all tests with:
 
 ```bash
-$ make test 
+$ make test
 ```
 
 The test files have a specific pattern: `'[Algorithm][Language]Test.py'`:
diff --git a/sklearn_porter/__init__.py b/sklearn_porter/__init__.py
@@ -33,6 +33,7 @@ def _load_meta(path):
             readme_path = join(src_dir, readme_path)
             readme = open(readme_path, 'r').read().strip()
             meta['long_description'] = readme
+
     return meta
 
 
diff --git a/sklearn_porter/cli/__main__.py b/sklearn_porter/cli/__main__.py
@@ -1,7 +1,11 @@
 # -*- coding: utf-8 -*-
 
 import sys
-import argparse
+
+from argparse import ArgumentParser
+from argparse import RawTextHelpFormatter
+from argparse import SUPPRESS
+from argparse import _HelpAction
 
 from os import sep
 from os.path import isdir
@@ -26,81 +30,70 @@ def parse_args(args):
     summary = dict(
         usage=header,
         description=meta.get('description'),
-        epilog='More details on ' + meta.get('url')
+        epilog='More details on ' + meta.get('url'),
+        formatter_class=RawTextHelpFormatter,
+        add_help=False
     )
-
-    parser = argparse.ArgumentParser(**summary)
+    p = ArgumentParser(**summary)
 
     # Remove the default arguments group:
-    parser._action_groups.pop()
-
-    # Required arguments:
-    required = parser.add_argument_group('Required arguments')
-    required.add_argument('--input', '-i',
-                          required=True,
-                          help=('Path to an exported estimator in pickle '
-                                '(.pkl) format.'))
+    p._action_groups.pop()
+
+    # File arguments:
+    files = p.add_argument_group('File arguments')
+    help = 'Path to an exported estimator in pickle (.pkl) format.'
+    files.add_argument('input', help=help)
+    help = 'Path to the output directory where ' \
+           'the transpiled estimator will be stored.'
+    files.add_argument('--to', required=False, help=help)
+
+    # Template arguments:
+    templates = p.add_argument_group('Template arguments')
+    templates.add_argument('--class_name', default=None, required=False,
+                           help='Define a custom class name.')
+    templates.add_argument('--method_name', default='predict', required=False,
+                           help='Define a custom method name.')
 
     # Optional arguments:
-    optional = parser.add_argument_group('Optional arguments')
-    optional.add_argument('--output', '-o',
-                          required=False,
-                          help=('Path to the destination directory where the '
-                                'transpiled estimator will be stored.'))
-    optional.add_argument('--class_name',
-                          default=None,
-                          required=False,
-                          help='Define the class name in the final output.')
-    optional.add_argument('--method_name',
-                          default='predict',
-                          required=False,
-                          help='Define the method name in the final output.')
-    optional.add_argument('--export', '-e',
-                          required=False,
-                          default=False,
-                          action='store_true',
-                          help='Whether to export the model data or not.')
-    optional.add_argument('--checksum', '-s',
-                          required=False,
-                          default=False,
-                          action='store_true',
-                          help='Whether to append the checksum to the '
-                               'filename or not.')
-    optional.add_argument('--data', '-d',
-                          required=False,
-                          default=False,
-                          action='store_true',
-                          help='Whether to export just the model data or all.')
-    optional.add_argument('--pipe', '-p',
-                          required=False,
-                          default=False,
-                          action='store_true',
-                          help='Print the transpiled estimator to the console.')
-
-    # Languages:
-    langs = parser.add_argument_group('Programming languages')
+    optional = p.add_argument_group('Optional arguments')
+    optional.add_argument('--export', '-e', required=False, default=False,
+                          action='store_true', help='Whether to export '
+                                                    'the model data or not.')
+    optional.add_argument('--checksum', '-s', required=False, default=False,
+                          action='store_true', help='Whether to append the '
+                                                    'checksum to the filename '
+                                                    'or not.')
+    optional.add_argument('--data', '-d', required=False, default=False,
+                          action='store_true', help='Whether to export just '
+                                                    'the model data or all.')
+    optional.add_argument('--pipe', '-p', required=False, default=False,
+                          action='store_true', help='Print the transpiled '
+                                                    'estimator to the console.')
+
+    # Programming languages:
+    langs = p.add_argument_group('Programming languages')
     languages = {key: clazz.LABEL for key, clazz in list(LANGUAGES.items())}
-    langs.add_argument('--language', '-l',
-                       choices=languages.keys(),
-                       default='java',
-                       required=False,
-                       help=argparse.SUPPRESS)
+    langs.add_argument('--language', '-l', choices=languages.keys(),
+                       default='java', required=False, help=SUPPRESS)
     for key, label in list(languages.items()):
         help = 'Set \'{}\' as the target programming language.'.format(label)
         langs.add_argument('--{}'.format(key), action='store_true', help=help)
 
     # Extra arguments:
-    extras = parser.add_argument_group('Extra arguments')
+    extras = p.add_argument_group('Extra arguments')
     extras.add_argument('--version', '-v', action='version',
-                        version='sklearn-porter v{}'.format(version))
+                        version='sklearn-porter v{}'.format(version),
+                        help='Show the version number and exit.')
+    extras.add_argument('--help', '-h', action=_HelpAction,
+                        help="Show this help message and exit.")
 
     # Show help by default:
     if len(sys.argv) == 1:
-        parser.print_help(sys.stderr)
+        p.print_help(sys.stderr)
         sys.exit(1)
 
     # Return dictionary:
-    args = vars(parser.parse_args(args))
+    args = vars(p.parse_args(args))
     return args
 
 
@@ -126,7 +119,7 @@ def main():
             break
 
     # Define destination path:
-    dest_dir = str(args.get('output'))
+    dest_dir = str(args.get('to'))
     if dest_dir == '' or not isdir(dest_dir):
         dest_dir = pkl_file_path.split(sep)
         del dest_dir[-1]
diff --git a/tests/PorterTest.py b/tests/PorterTest.py
@@ -67,7 +67,7 @@ def test_python_command_execution(self):
         joblib.dump(self.estimator, pkl_path)
 
         # Port estimator:
-        cmd = 'python -m sklearn_porter.cli.__main__ -i {}' \
+        cmd = 'python -m sklearn_porter.cli.__main__ {}' \
               ' --class_name Brain'.format(pkl_path)
         Shell.call(cmd)
         # Compare file contents:
