scripts.config_generator.arg_parsers._get_verbosity() - Code Metrics - Inspection of "Merge pull request #897 from DiamondLightSource/je..." - DiamondLightSource/Savu - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 62239c...9ba79c )

unknown

created 2022-02-15 15:15 UTC

_get_verbosity() A

↳ Parent: scripts.config_generator.arg_parsers

Complexity

Conditions

Size

Total Lines	9
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	8
nop	1
dl	0
loc	9
rs	10
c	0
b	0
f	0

# Copyright 2014 Diamond Light Source Ltd.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""
.. module:: arg_parsers
   :platform: Unix
   :synopsis: Contains all the argparse instances for configurator \
       input commands.

.. moduleauthor:: Nicola Wadeson <[email protected]>

"""
import argparse

from . import savu_config as sc


class MyException(Exception):
    def __init__(self, message, args=None):
        super(MyException, self).__init__(message)
        self.args = args

    def args(self):
        return self.args


class ArgumentParser(argparse.ArgumentParser):

    def error(self, message):
        raise MyException(message)

    def exit(self, status=0, message=None):
        raise MyException(message)


def __arg_parser(parser, args, command, doc):
    try:
        args = parser.parse_args(args=args)
    except MyException as e:
        args = e.args
        if args is not None:
            print(e)
        print(f"Please type '{command} -h' for help.")
    return parser if doc==True else args


def _config_arg_parser(doc=True):
    """ Argument parser for command line arguments. """
    desc = "Create process lists of plugins for Savu."
    parser = argparse.ArgumentParser(prog='savu_config.py', description=desc)
    disp_str = "Set the display level to show ALL parameters by default."
    parser.add_argument("-a", "--all", action="store_true", dest="disp_all",
                        help=disp_str, default=False)
    input_str = "Open a Savu process list."
    parser.add_argument("-i", "--input", dest="file", help=input_str)
    parser.add_argument("-e", "--error", dest="error", help="Shows all errors that Savu encounters.",
                        action='store_true', default=False)
    parser.add_argument("--examples", dest="examples", action='store_true',
                        help="Add example plugins.", default=False)
    parser.add_argument("--tree", dest="tree",
                        help="Display the tree view of a hdf/nxs file.",
                        type=str, default=None, required=False)
    parser.add_argument("--check", dest="check",
                        help="Check if a tomographic data file (hdf/nxs) contains conventional"
                             " dataset-paths for NxTomoLoader.",
                        type=str, default=None, required=False)
    parser.add_argument("--find", dest="find", nargs=2, action="append",
                        help="Find paths to datasets in a hdf/nxs file matching a pattern",
                        type=str, default=None, required=False)
    return parser if doc==True else parser.parse_args()


def __verbosity_arguments(parser, q_str, v_str, vv_str):
    """ Add verbosity arguments to a parser. """
    parser.add_argument("-q", "--quiet", action="store_true", dest="quiet",
                        help="Quiet mode. "+q_str, default=False)
    parser.add_argument("-v", "--verbose", action="store_true", dest="verbose",
                        help="Verbose mode. "+v_str, default=False)
    parser.add_argument("-vv", "--vverbose", action="store_true",
                        dest="vverbose", help="Verbose verbose mode. "+vv_str,
                        default=False)


def _open_arg_parser(args=None, doc=True):
    """ Argument parser for open command. """
    desc = sc.get_description()['open']
    parser = ArgumentParser(prog='open', description=desc)
    file_str = "The path to the process list to open."
    parser.add_argument('file', help=file_str)
    parser.add_argument('-s', '--skip', help='Skip broken plugins.',
                        action='store_true', default=False)
    return __arg_parser(parser, args, 'open', doc)


def _disp_arg_parser(args=None, doc=True):
    """ Argument parser for disp command. """
    desc = sc.get_description()['disp']
    parser = ArgumentParser(prog='disp', description=desc)
    q_str = "Display plugin names only."
    v_str = "Display plugin names, synopsis and parameter details."
    vv_str = \
        "Display plugin names, full synopsis, parameter details and warnings."
    __verbosity_arguments(parser, q_str, v_str, vv_str)

    all_str = "Display ALL parameters (user parameters only by default)."
    parser.add_argument("-a", "--all", action='store_true', help=all_str,
                        default=False)
    l_str = "Display current parameter visibility level."
    parser.add_argument("-l", "--level", action='store_true', help=l_str,
                        default=False)
    dataset_str = "Display in_datasets and out_datasets."
    parser.add_argument("-d", "--datasets", action='store_true', help=dataset_str,
                        default=False)

    parser.add_argument("start", nargs='?', help="Display this list entry.")
    stop_str = "Display entries from start to stop."
    parser.add_argument("stop", nargs='?', help=stop_str)
    return __arg_parser(parser, args, 'disp', doc)


def _list_arg_parser(args=None, doc=True):
    """ Argument parser for list command. """
    desc = sc.get_description()['list']
    parser = ArgumentParser(prog='list', description=desc)
    q_str = "List plugin names only."
    v_str = "List plugin names and full synopsis."
    vv_str = "List all information."
    __verbosity_arguments(parser, q_str, v_str, vv_str)
    type_str = "List plugins or collections containing this string."
    parser.add_argument("string", nargs='?', help=type_str, default="")
    return __arg_parser(parser, args, 'list', doc)


def _save_arg_parser(args=None, doc=True):
    """ Argument parser for save command. """
    desc = sc.get_description()['save']
    parser = ArgumentParser(prog='save', description=desc)
    parser.add_argument("filepath", nargs='?', help="The output file path.")
    parser.add_argument("-i", "--input", action="store_true", default=False,
                        help="Save to the input file.")
    parser.add_argument("-t", "--template", action="store_true", default=False,
                        help="Create a Savu template file.")
    return __arg_parser(parser, args, 'save', doc)


def _mod_arg_parser(args=None, doc=True):
    """ Argument parser for mod command. """
    # required to allow negative values in a list or tuple
    if args:
        args.insert(1, '--')
    desc = sc.get_description()['mod']
    parser = ArgumentParser(prog='mod', description=desc)
    param_str = ("The plugin parameter to modify. Either "
                 "'plugin_pos.param_name' or ' plugin_pos.param_no'")
    parser.add_argument("param", help=param_str)
    val_str = "The plugin parameter value."
    parser.add_argument("value", nargs='*', help=val_str)
    parser.add_argument("-d", "--default", action="store_true", default=False,
                        help="Revert to default value.")
    return __arg_parser(parser, args, 'mod', doc)


def _set_arg_parser(args=None, doc=True):
    """ Argument parser for set command. """
    desc = sc.get_description()['set']
    parser = ArgumentParser(prog='set', description=desc)
    parser.add_argument('plugin_pos', type=str, nargs='+',
                        help="Plugin position(s).")
    parser.add_argument("status", type=str, choices=['on', 'ON', 'off', 'OFF'],
                        help="Plugin status.")
    return __arg_parser(parser, args, 'set', doc)


def _add_arg_parser(args=None, doc=True):
    """ Argument parser for add command. """
    desc = sc.get_description()['add']
    parser = ArgumentParser(prog='add', description=desc)
    parser.add_argument("name", help="The plugin name.")
    pos_str = "Plugin list position (defaults to end)."
    parser.add_argument('pos', nargs='?', help=pos_str)
    return __arg_parser(parser, args, 'add', doc)


def _dupl_arg_parser(args=None, doc=True):
    """ Argument parser for dupl command. """
    desc = sc.get_description()['dupl']
    parser = ArgumentParser(prog='dupl', description=desc)
    orig_pos_str = "The position of the plugin to be duplicated."
    parser.add_argument("orig_pos", help=orig_pos_str)
    pos_str = "Position for the new plugin (defaults to end)."
    parser.add_argument('new_pos', nargs='?', help=pos_str)
    return __arg_parser(parser, args, 'dupl', doc)


def _ref_arg_parser(args=None, doc=True):
    """ Argument parser for ref command. """
    desc = sc.get_description()['ref']
    parser = ArgumentParser(prog='ref', description=desc)
    plugin_str = "Plugin position to refresh or '*' for the whole list"
    parser.add_argument("pos", nargs='+', help=plugin_str)
    defaults_str = "Populate parameters with default values."
    parser.add_argument("-d", "--defaults", "--default", action="store_true",
                        dest="defaults", help=defaults_str, default=False)
    parser.add_argument("-n", "--nodisp", action="store_true", dest="nodisp",
                        help=argparse.SUPPRESS, default=False)
    return __arg_parser(parser, args, 'ref', doc)


def _rem_arg_parser(args=None, doc=True):
    """ Argument parser for rem command. """
    desc = sc.get_description()['rem']
    parser = ArgumentParser(prog='rem', description=desc)
    parser.add_argument('pos', type=str, nargs='+',
                            help="Plugin position(s).")
    return __arg_parser(parser, args, 'rem', doc)


def _cite_arg_parser(args=None, doc=True):
    """ Argument parser for cite command. """
    desc = sc.get_description()['cite']
    parser = ArgumentParser(prog='cite', description=desc)
    parser.add_argument("start", nargs='?', help="Display this plugin citation.")
    stop_str = "Display plugins from start to stop."
    parser.add_argument("stop", nargs='?', help=stop_str)
    return __arg_parser(parser, args, 'cite', doc)


def _move_arg_parser(args=None, doc=True):
    """ Argument parser for move command. """
    desc = sc.get_description()['move']
    parser = ArgumentParser(prog='move', description=desc)
    parser.add_argument("orig_pos", help="Original position.")
    parser.add_argument('new_pos', help="New position.")
    return __arg_parser(parser, args, 'move', doc)


def _replace_arg_parser(args=None, doc=True):
    """ Argument parser for replace command. """
    desc = sc.get_description()['replace']
    parser = ArgumentParser(prog='replace', description=desc)
    parser.add_argument("old", help="Old plugin position.")
    parser.add_argument('new_plugin', help="New plugin name.")
    return __arg_parser(parser, args, 'replace', doc)


def _coll_arg_parser(args=None, doc=True):
    """ Argument parser for coll command. """
    desc = sc.get_description()['coll']
    parser = ArgumentParser(prog='coll', description=desc)
    return __arg_parser(parser, args, 'coll', doc)


def _level_arg_parser(args=None, doc=True):
    """ Argument parser for level command. """
    desc = sc.get_description()['level']
    parser = ArgumentParser(prog='level', description=desc)
    level_str = "The visibility level. Display the current visibility level" \
                " by using 'level' without an argument."
    parser.add_argument("level",  nargs='?', help=level_str
                        , choices=['basic', 'intermediate', 'advanced'])
    return __arg_parser(parser, args, 'level', doc)


def _expand_arg_parser(args=None, doc=True):
    """ Argument parser for expand command. """
    desc = sc.get_description()["expand"]
    parser = ArgumentParser(prog="expand", description=desc)
    plugin_pos_str = "Expand this plugin preview parameter"
    parser.add_argument("plugin_pos", nargs="?", help=plugin_pos_str)
    dim_str = "Data dimensions. If this value is the same as the " \
              "current dimension value, then the dimension of the " \
              "preview parameter will be unchanged. If it is greater " \
              "or smaller than the current dimension value, then the " \
              "dimension of the preview value will be altered."
    parser.add_argument("dim", nargs="?", type=int, help=dim_str)
    # Hidden argument to use when argument can be string and one
    # dimension is displayed
    parser.add_argument('dim_view', nargs="?", default=False,
                        help=argparse.SUPPRESS)
    expand_off_str = "Turn off the expand view"
    parser.add_argument("--off", action="store_true",
                        dest="off", help=expand_off_str, default=False)
    return __arg_parser(parser, args, "expand", doc)


def _clear_arg_parser(args=None, doc=True):
    """ Argument parser for clear command. """
    desc = sc.get_description()['clear']
    parser = ArgumentParser(prog='clear', description=desc)
    return __arg_parser(parser, args, 'clear', doc)


def _history_arg_parser(args=None, doc=True):
    """ Argument parser for history command. """
    desc = sc.get_description()['history']
    parser = ArgumentParser(prog='history', description=desc)
    return __arg_parser(parser, args, 'history', doc)


def _exit_arg_parser(args=None, doc=True):
    """ Argument parser for exit command """
    desc = sc.get_description()['exit']
    parser = ArgumentParser(prog='exit', description=desc)
    return __arg_parser(parser, args, 'exit', doc)


def _help_arg_parser(args=None, doc=True):
    """ Argument parser for help command """
    desc = sc.get_description()['help']
    parser = ArgumentParser(prog='help', description=desc)
    return __arg_parser(parser, args, 'help', doc)


def _get_verbosity(args):
    if args.vverbose:
        return '-vv'
    elif args.verbose:
        return '-v'
    elif args.quiet:
        return '-q'
    else:
        return None


1			# Copyright 2014 Diamond Light Source Ltd.
2			#
3			# Licensed under the Apache License, Version 2.0 (the "License");
4			# you may not use this file except in compliance with the License.
5			# You may obtain a copy of the License at
6			#
7			# http://www.apache.org/licenses/LICENSE-2.0
8			#
9			# Unless required by applicable law or agreed to in writing, software
10			# distributed under the License is distributed on an "AS IS" BASIS,
11			# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12			# See the License for the specific language governing permissions and
13			# limitations under the License.
14
15			"""
16			.. module:: arg_parsers
17			:platform: Unix
18			:synopsis: Contains all the argparse instances for configurator \
19			input commands.
20
21			.. moduleauthor:: Nicola Wadeson <[email protected]>
22
23			"""
24			import argparse
25
26			from . import savu_config as sc
27
28
29			class MyException(Exception):
30			def __init__(self, message, args=None):
31			super(MyException, self).__init__(message)
32			self.args = args
33
34			def args(self):
35			return self.args
36
37
38			class ArgumentParser(argparse.ArgumentParser):
39
40			def error(self, message):
41			raise MyException(message)
42
43			def exit(self, status=0, message=None):
44			raise MyException(message)
45
46
47			def __arg_parser(parser, args, command, doc):
48			try:
49			args = parser.parse_args(args=args)
50			except MyException as e:
51			args = e.args
52			if args is not None:
53			print(e)
54			print(f"Please type '{command} -h' for help.")
55			return parser if doc==True else args
56
57
58			def _config_arg_parser(doc=True):
59			""" Argument parser for command line arguments. """
60			desc = "Create process lists of plugins for Savu."
61			parser = argparse.ArgumentParser(prog='savu_config.py', description=desc)
62			disp_str = "Set the display level to show ALL parameters by default."
63			parser.add_argument("-a", "--all", action="store_true", dest="disp_all",
64			help=disp_str, default=False)
65			input_str = "Open a Savu process list."
66			parser.add_argument("-i", "--input", dest="file", help=input_str)
67			parser.add_argument("-e", "--error", dest="error", help="Shows all errors that Savu encounters.",
68			action='store_true', default=False)
69			parser.add_argument("--examples", dest="examples", action='store_true',
70			help="Add example plugins.", default=False)
71			parser.add_argument("--tree", dest="tree",
72			help="Display the tree view of a hdf/nxs file.",
73			type=str, default=None, required=False)
74			parser.add_argument("--check", dest="check",
75			help="Check if a tomographic data file (hdf/nxs) contains conventional"
76			" dataset-paths for NxTomoLoader.",
77			type=str, default=None, required=False)
78			parser.add_argument("--find", dest="find", nargs=2, action="append",
79			help="Find paths to datasets in a hdf/nxs file matching a pattern",
80			type=str, default=None, required=False)
81			return parser if doc==True else parser.parse_args()
82
83
84			def __verbosity_arguments(parser, q_str, v_str, vv_str):
85			""" Add verbosity arguments to a parser. """
86			parser.add_argument("-q", "--quiet", action="store_true", dest="quiet",
87			help="Quiet mode. "+q_str, default=False)
88			parser.add_argument("-v", "--verbose", action="store_true", dest="verbose",
89			help="Verbose mode. "+v_str, default=False)
90			parser.add_argument("-vv", "--vverbose", action="store_true",
91			dest="vverbose", help="Verbose verbose mode. "+vv_str,
92			default=False)
93
94
95			def _open_arg_parser(args=None, doc=True):
96			""" Argument parser for open command. """
97			desc = sc.get_description()['open']
98			parser = ArgumentParser(prog='open', description=desc)
99			file_str = "The path to the process list to open."
100			parser.add_argument('file', help=file_str)
101			parser.add_argument('-s', '--skip', help='Skip broken plugins.',
102			action='store_true', default=False)
103			return __arg_parser(parser, args, 'open', doc)
104
105
106			def _disp_arg_parser(args=None, doc=True):
107			""" Argument parser for disp command. """
108			desc = sc.get_description()['disp']
109			parser = ArgumentParser(prog='disp', description=desc)
110			q_str = "Display plugin names only."
111			v_str = "Display plugin names, synopsis and parameter details."
112			vv_str = \
113			"Display plugin names, full synopsis, parameter details and warnings."
114			__verbosity_arguments(parser, q_str, v_str, vv_str)
115
116			all_str = "Display ALL parameters (user parameters only by default)."
117			parser.add_argument("-a", "--all", action='store_true', help=all_str,
118			default=False)
119			l_str = "Display current parameter visibility level."
120			parser.add_argument("-l", "--level", action='store_true', help=l_str,
121			default=False)
122			dataset_str = "Display in_datasets and out_datasets."
123			parser.add_argument("-d", "--datasets", action='store_true', help=dataset_str,
124			default=False)
125
126			parser.add_argument("start", nargs='?', help="Display this list entry.")
127			stop_str = "Display entries from start to stop."
128			parser.add_argument("stop", nargs='?', help=stop_str)
129			return __arg_parser(parser, args, 'disp', doc)
130
131
132			def _list_arg_parser(args=None, doc=True):
133			""" Argument parser for list command. """
134			desc = sc.get_description()['list']
135			parser = ArgumentParser(prog='list', description=desc)
136			q_str = "List plugin names only."
137			v_str = "List plugin names and full synopsis."
138			vv_str = "List all information."
139			__verbosity_arguments(parser, q_str, v_str, vv_str)
140			type_str = "List plugins or collections containing this string."
141			parser.add_argument("string", nargs='?', help=type_str, default="")
142			return __arg_parser(parser, args, 'list', doc)
143
144
145			def _save_arg_parser(args=None, doc=True):
146			""" Argument parser for save command. """
147			desc = sc.get_description()['save']
148			parser = ArgumentParser(prog='save', description=desc)
149			parser.add_argument("filepath", nargs='?', help="The output file path.")
150			parser.add_argument("-i", "--input", action="store_true", default=False,
151			help="Save to the input file.")
152			parser.add_argument("-t", "--template", action="store_true", default=False,
153			help="Create a Savu template file.")
154			return __arg_parser(parser, args, 'save', doc)
155
156
157			def _mod_arg_parser(args=None, doc=True):
158			""" Argument parser for mod command. """
159			# required to allow negative values in a list or tuple
160			if args:
161			args.insert(1, '--')
162			desc = sc.get_description()['mod']
163			parser = ArgumentParser(prog='mod', description=desc)
164			param_str = ("The plugin parameter to modify. Either "
165			"'plugin_pos.param_name' or ' plugin_pos.param_no'")
166			parser.add_argument("param", help=param_str)
167			val_str = "The plugin parameter value."
168			parser.add_argument("value", nargs='*', help=val_str)
169			parser.add_argument("-d", "--default", action="store_true", default=False,
170			help="Revert to default value.")
171			return __arg_parser(parser, args, 'mod', doc)
172
173
174			def _set_arg_parser(args=None, doc=True):
175			""" Argument parser for set command. """
176			desc = sc.get_description()['set']
177			parser = ArgumentParser(prog='set', description=desc)
178			parser.add_argument('plugin_pos', type=str, nargs='+',
179			help="Plugin position(s).")
180			parser.add_argument("status", type=str, choices=['on', 'ON', 'off', 'OFF'],
181			help="Plugin status.")
182			return __arg_parser(parser, args, 'set', doc)
183
184
185			def _add_arg_parser(args=None, doc=True):
186			""" Argument parser for add command. """
187			desc = sc.get_description()['add']
188			parser = ArgumentParser(prog='add', description=desc)
189			parser.add_argument("name", help="The plugin name.")
190			pos_str = "Plugin list position (defaults to end)."
191			parser.add_argument('pos', nargs='?', help=pos_str)
192			return __arg_parser(parser, args, 'add', doc)
193
194
195			def _dupl_arg_parser(args=None, doc=True):
196			""" Argument parser for dupl command. """
197			desc = sc.get_description()['dupl']
198			parser = ArgumentParser(prog='dupl', description=desc)
199			orig_pos_str = "The position of the plugin to be duplicated."
200			parser.add_argument("orig_pos", help=orig_pos_str)
201			pos_str = "Position for the new plugin (defaults to end)."
202			parser.add_argument('new_pos', nargs='?', help=pos_str)
203			return __arg_parser(parser, args, 'dupl', doc)
204
205
206			def _ref_arg_parser(args=None, doc=True):
207			""" Argument parser for ref command. """
208			desc = sc.get_description()['ref']
209			parser = ArgumentParser(prog='ref', description=desc)
210			plugin_str = "Plugin position to refresh or '*' for the whole list"
211			parser.add_argument("pos", nargs='+', help=plugin_str)
212			defaults_str = "Populate parameters with default values."
213			parser.add_argument("-d", "--defaults", "--default", action="store_true",
214			dest="defaults", help=defaults_str, default=False)
215			parser.add_argument("-n", "--nodisp", action="store_true", dest="nodisp",
216			help=argparse.SUPPRESS, default=False)
217			return __arg_parser(parser, args, 'ref', doc)
218
219
220			def _rem_arg_parser(args=None, doc=True):
221			""" Argument parser for rem command. """
222			desc = sc.get_description()['rem']
223			parser = ArgumentParser(prog='rem', description=desc)
224			parser.add_argument('pos', type=str, nargs='+',
225			help="Plugin position(s).")
226			return __arg_parser(parser, args, 'rem', doc)
227
228
229			def _cite_arg_parser(args=None, doc=True):
230			""" Argument parser for cite command. """
231			desc = sc.get_description()['cite']
232			parser = ArgumentParser(prog='cite', description=desc)
233			parser.add_argument("start", nargs='?', help="Display this plugin citation.")
234			stop_str = "Display plugins from start to stop."
235			parser.add_argument("stop", nargs='?', help=stop_str)
236			return __arg_parser(parser, args, 'cite', doc)
237
238
239			def _move_arg_parser(args=None, doc=True):
240			""" Argument parser for move command. """
241			desc = sc.get_description()['move']
242			parser = ArgumentParser(prog='move', description=desc)
243			parser.add_argument("orig_pos", help="Original position.")
244			parser.add_argument('new_pos', help="New position.")
245			return __arg_parser(parser, args, 'move', doc)
246
247
248			def _replace_arg_parser(args=None, doc=True):
249			""" Argument parser for replace command. """
250			desc = sc.get_description()['replace']
251			parser = ArgumentParser(prog='replace', description=desc)
252			parser.add_argument("old", help="Old plugin position.")
253			parser.add_argument('new_plugin', help="New plugin name.")
254			return __arg_parser(parser, args, 'replace', doc)
255
256
257			def _coll_arg_parser(args=None, doc=True):
258			""" Argument parser for coll command. """
259			desc = sc.get_description()['coll']
260			parser = ArgumentParser(prog='coll', description=desc)
261			return __arg_parser(parser, args, 'coll', doc)
262
263
264			def _level_arg_parser(args=None, doc=True):
265			""" Argument parser for level command. """
266			desc = sc.get_description()['level']
267			parser = ArgumentParser(prog='level', description=desc)
268			level_str = "The visibility level. Display the current visibility level" \
269			" by using 'level' without an argument."
270			parser.add_argument("level", nargs='?', help=level_str
271			, choices=['basic', 'intermediate', 'advanced'])
272			return __arg_parser(parser, args, 'level', doc)
273
274
275			def _expand_arg_parser(args=None, doc=True):
276			""" Argument parser for expand command. """
277			desc = sc.get_description()["expand"]
278			parser = ArgumentParser(prog="expand", description=desc)
279			plugin_pos_str = "Expand this plugin preview parameter"
280			parser.add_argument("plugin_pos", nargs="?", help=plugin_pos_str)
281			dim_str = "Data dimensions. If this value is the same as the " \
282			"current dimension value, then the dimension of the " \
283			"preview parameter will be unchanged. If it is greater " \
284			"or smaller than the current dimension value, then the " \
285			"dimension of the preview value will be altered."
286			parser.add_argument("dim", nargs="?", type=int, help=dim_str)
287			# Hidden argument to use when argument can be string and one
288			# dimension is displayed
289			parser.add_argument('dim_view', nargs="?", default=False,
290			help=argparse.SUPPRESS)
291			expand_off_str = "Turn off the expand view"
292			parser.add_argument("--off", action="store_true",
293			dest="off", help=expand_off_str, default=False)
294			return __arg_parser(parser, args, "expand", doc)
295
296
297			def _clear_arg_parser(args=None, doc=True):
298			""" Argument parser for clear command. """
299			desc = sc.get_description()['clear']
300			parser = ArgumentParser(prog='clear', description=desc)
301			return __arg_parser(parser, args, 'clear', doc)
302
303
304			def _history_arg_parser(args=None, doc=True):
305			""" Argument parser for history command. """
306			desc = sc.get_description()['history']
307			parser = ArgumentParser(prog='history', description=desc)
308			return __arg_parser(parser, args, 'history', doc)
309
310
311			def _exit_arg_parser(args=None, doc=True):
312			""" Argument parser for exit command """
313			desc = sc.get_description()['exit']
314			parser = ArgumentParser(prog='exit', description=desc)
315			return __arg_parser(parser, args, 'exit', doc)
316
317
318			def _help_arg_parser(args=None, doc=True):
319			""" Argument parser for help command """
320			desc = sc.get_description()['help']
321			parser = ArgumentParser(prog='help', description=desc)
322			return __arg_parser(parser, args, 'help', doc)
323
324
325			def _get_verbosity(args):
326			if args.vverbose:
327			return '-vv'
328			elif args.verbose:
329			return '-v'
330			elif args.quiet:
331			return '-q'
332			else:
333			return None
334

DiamondLightSource / Savu

Push — master ( 62239c...9ba79c )

_get_verbosity() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like