Skip to content
GitLab
Menu
Projects
Groups
Snippets
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
flexpart
flexpart
Commits
dfb516e9
Commit
dfb516e9
authored
Aug 31, 2016
by
Don Morton
Browse files
Minor additions to FPv9.3.1 testing and compilation environments
parent
b89ec947
Changes
3
Hide whitespace changes
Inline
Side-by-side
flexpart-testing/.gitignore
0 → 100644
View file @
dfb516e9
*.pyc
flexpart-testing/check/argparse.py
0 → 100644
View file @
dfb516e9
# Author: Steven J. Bethard <steven.bethard@gmail.com>.
"""Command-line parsing library
This module is an optparse-inspired command-line parsing library that:
- handles both optional and positional arguments
- produces highly informative usage messages
- supports parsers that dispatch to sub-parsers
The following is a simple usage example that sums integers from the
command-line and writes the result to a file::
parser = argparse.ArgumentParser(
description='sum the integers at the command line')
parser.add_argument(
'integers', metavar='int', nargs='+', type=int,
help='an integer to be summed')
parser.add_argument(
'--log', default=sys.stdout, type=argparse.FileType('w'),
help='the file where the sum should be written')
args = parser.parse_args()
args.log.write('%s' % sum(args.integers))
args.log.close()
The module contains the following public classes:
- ArgumentParser -- The main entry point for command-line parsing. As the
example above shows, the add_argument() method is used to populate
the parser with actions for optional and positional arguments. Then
the parse_args() method is invoked to convert the args at the
command-line into an object with attributes.
- ArgumentError -- The exception raised by ArgumentParser objects when
there are errors with the parser's actions. Errors raised while
parsing the command-line are caught by ArgumentParser and emitted
as command-line messages.
- FileType -- A factory for defining types of files to be created. As the
example above shows, instances of FileType are typically passed as
the type= argument of add_argument() calls.
- Action -- The base class for parser actions. Typically actions are
selected by passing strings like 'store_true' or 'append_const' to
the action= argument of add_argument(). However, for greater
customization of ArgumentParser actions, subclasses of Action may
be defined and passed as the action= argument.
- HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter,
ArgumentDefaultsHelpFormatter -- Formatter classes which
may be passed as the formatter_class= argument to the
ArgumentParser constructor. HelpFormatter is the default,
RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser
not to change the formatting for help text, and
ArgumentDefaultsHelpFormatter adds information about argument defaults
to the help.
All other classes in this module are considered implementation details.
(Also note that HelpFormatter and RawDescriptionHelpFormatter are only
considered public as object names -- the API of the formatter objects is
still considered an implementation detail.)
"""
__version__
=
'1.1'
__all__
=
[
'ArgumentParser'
,
'ArgumentError'
,
'ArgumentTypeError'
,
'FileType'
,
'HelpFormatter'
,
'ArgumentDefaultsHelpFormatter'
,
'RawDescriptionHelpFormatter'
,
'RawTextHelpFormatter'
,
'Namespace'
,
'Action'
,
'ONE_OR_MORE'
,
'OPTIONAL'
,
'PARSER'
,
'REMAINDER'
,
'SUPPRESS'
,
'ZERO_OR_MORE'
,
]
import
collections
as
_collections
import
copy
as
_copy
import
os
as
_os
import
re
as
_re
import
sys
as
_sys
import
textwrap
as
_textwrap
from
gettext
import
gettext
as
_
def
_callable
(
obj
):
return
hasattr
(
obj
,
'__call__'
)
or
hasattr
(
obj
,
'__bases__'
)
SUPPRESS
=
'==SUPPRESS=='
OPTIONAL
=
'?'
ZERO_OR_MORE
=
'*'
ONE_OR_MORE
=
'+'
PARSER
=
'A...'
REMAINDER
=
'...'
_UNRECOGNIZED_ARGS_ATTR
=
'_unrecognized_args'
# =============================
# Utility functions and classes
# =============================
class
_AttributeHolder
(
object
):
"""Abstract base class that provides __repr__.
The __repr__ method returns a string in the format::
ClassName(attr=name, attr=name, ...)
The attributes are determined either by a class-level attribute,
'_kwarg_names', or by inspecting the instance __dict__.
"""
def
__repr__
(
self
):
type_name
=
type
(
self
).
__name__
arg_strings
=
[]
for
arg
in
self
.
_get_args
():
arg_strings
.
append
(
repr
(
arg
))
for
name
,
value
in
self
.
_get_kwargs
():
arg_strings
.
append
(
'%s=%r'
%
(
name
,
value
))
return
'%s(%s)'
%
(
type_name
,
', '
.
join
(
arg_strings
))
def
_get_kwargs
(
self
):
return
sorted
(
self
.
__dict__
.
items
())
def
_get_args
(
self
):
return
[]
def
_ensure_value
(
namespace
,
name
,
value
):
if
getattr
(
namespace
,
name
,
None
)
is
None
:
setattr
(
namespace
,
name
,
value
)
return
getattr
(
namespace
,
name
)
# ===============
# Formatting Help
# ===============
class
HelpFormatter
(
object
):
"""Formatter for generating usage messages and argument help strings.
Only the name of this class is considered a public API. All the methods
provided by the class are considered an implementation detail.
"""
def
__init__
(
self
,
prog
,
indent_increment
=
2
,
max_help_position
=
24
,
width
=
None
):
# default setting for width
if
width
is
None
:
try
:
width
=
int
(
_os
.
environ
[
'COLUMNS'
])
except
(
KeyError
,
ValueError
):
width
=
80
width
-=
2
self
.
_prog
=
prog
self
.
_indent_increment
=
indent_increment
self
.
_max_help_position
=
max_help_position
self
.
_max_help_position
=
min
(
max_help_position
,
max
(
width
-
20
,
indent_increment
*
2
))
self
.
_width
=
width
self
.
_current_indent
=
0
self
.
_level
=
0
self
.
_action_max_length
=
0
self
.
_root_section
=
self
.
_Section
(
self
,
None
)
self
.
_current_section
=
self
.
_root_section
self
.
_whitespace_matcher
=
_re
.
compile
(
r
'\s+'
)
self
.
_long_break_matcher
=
_re
.
compile
(
r
'\n\n\n+'
)
# ===============================
# Section and indentation methods
# ===============================
def
_indent
(
self
):
self
.
_current_indent
+=
self
.
_indent_increment
self
.
_level
+=
1
def
_dedent
(
self
):
self
.
_current_indent
-=
self
.
_indent_increment
assert
self
.
_current_indent
>=
0
,
'Indent decreased below 0.'
self
.
_level
-=
1
class
_Section
(
object
):
def
__init__
(
self
,
formatter
,
parent
,
heading
=
None
):
self
.
formatter
=
formatter
self
.
parent
=
parent
self
.
heading
=
heading
self
.
items
=
[]
def
format_help
(
self
):
# format the indented section
if
self
.
parent
is
not
None
:
self
.
formatter
.
_indent
()
join
=
self
.
formatter
.
_join_parts
for
func
,
args
in
self
.
items
:
func
(
*
args
)
item_help
=
join
([
func
(
*
args
)
for
func
,
args
in
self
.
items
])
if
self
.
parent
is
not
None
:
self
.
formatter
.
_dedent
()
# return nothing if the section was empty
if
not
item_help
:
return
''
# add the heading if the section was non-empty
if
self
.
heading
is
not
SUPPRESS
and
self
.
heading
is
not
None
:
current_indent
=
self
.
formatter
.
_current_indent
heading
=
'%*s%s:
\n
'
%
(
current_indent
,
''
,
self
.
heading
)
else
:
heading
=
''
# join the section-initial newline, the heading and the help
return
join
([
'
\n
'
,
heading
,
item_help
,
'
\n
'
])
def
_add_item
(
self
,
func
,
args
):
self
.
_current_section
.
items
.
append
((
func
,
args
))
# ========================
# Message building methods
# ========================
def
start_section
(
self
,
heading
):
self
.
_indent
()
section
=
self
.
_Section
(
self
,
self
.
_current_section
,
heading
)
self
.
_add_item
(
section
.
format_help
,
[])
self
.
_current_section
=
section
def
end_section
(
self
):
self
.
_current_section
=
self
.
_current_section
.
parent
self
.
_dedent
()
def
add_text
(
self
,
text
):
if
text
is
not
SUPPRESS
and
text
is
not
None
:
self
.
_add_item
(
self
.
_format_text
,
[
text
])
def
add_usage
(
self
,
usage
,
actions
,
groups
,
prefix
=
None
):
if
usage
is
not
SUPPRESS
:
args
=
usage
,
actions
,
groups
,
prefix
self
.
_add_item
(
self
.
_format_usage
,
args
)
def
add_argument
(
self
,
action
):
if
action
.
help
is
not
SUPPRESS
:
# find all invocations
get_invocation
=
self
.
_format_action_invocation
invocations
=
[
get_invocation
(
action
)]
for
subaction
in
self
.
_iter_indented_subactions
(
action
):
invocations
.
append
(
get_invocation
(
subaction
))
# update the maximum item length
invocation_length
=
max
([
len
(
s
)
for
s
in
invocations
])
action_length
=
invocation_length
+
self
.
_current_indent
self
.
_action_max_length
=
max
(
self
.
_action_max_length
,
action_length
)
# add the item to the list
self
.
_add_item
(
self
.
_format_action
,
[
action
])
def
add_arguments
(
self
,
actions
):
for
action
in
actions
:
self
.
add_argument
(
action
)
# =======================
# Help-formatting methods
# =======================
def
format_help
(
self
):
help
=
self
.
_root_section
.
format_help
()
if
help
:
help
=
self
.
_long_break_matcher
.
sub
(
'
\n\n
'
,
help
)
help
=
help
.
strip
(
'
\n
'
)
+
'
\n
'
return
help
def
_join_parts
(
self
,
part_strings
):
return
''
.
join
([
part
for
part
in
part_strings
if
part
and
part
is
not
SUPPRESS
])
def
_format_usage
(
self
,
usage
,
actions
,
groups
,
prefix
):
if
prefix
is
None
:
prefix
=
_
(
'usage: '
)
# if usage is specified, use that
if
usage
is
not
None
:
usage
=
usage
%
dict
(
prog
=
self
.
_prog
)
# if no optionals or positionals are available, usage is just prog
elif
usage
is
None
and
not
actions
:
usage
=
'%(prog)s'
%
dict
(
prog
=
self
.
_prog
)
# if optionals and positionals are available, calculate usage
elif
usage
is
None
:
prog
=
'%(prog)s'
%
dict
(
prog
=
self
.
_prog
)
# split optionals from positionals
optionals
=
[]
positionals
=
[]
for
action
in
actions
:
if
action
.
option_strings
:
optionals
.
append
(
action
)
else
:
positionals
.
append
(
action
)
# build full usage string
format
=
self
.
_format_actions_usage
action_usage
=
format
(
optionals
+
positionals
,
groups
)
usage
=
' '
.
join
([
s
for
s
in
[
prog
,
action_usage
]
if
s
])
# wrap the usage parts if it's too long
text_width
=
self
.
_width
-
self
.
_current_indent
if
len
(
prefix
)
+
len
(
usage
)
>
text_width
:
# break usage into wrappable parts
part_regexp
=
r
'\(.*?\)+|\[.*?\]+|\S+'
opt_usage
=
format
(
optionals
,
groups
)
pos_usage
=
format
(
positionals
,
groups
)
opt_parts
=
_re
.
findall
(
part_regexp
,
opt_usage
)
pos_parts
=
_re
.
findall
(
part_regexp
,
pos_usage
)
assert
' '
.
join
(
opt_parts
)
==
opt_usage
assert
' '
.
join
(
pos_parts
)
==
pos_usage
# helper for wrapping lines
def
get_lines
(
parts
,
indent
,
prefix
=
None
):
lines
=
[]
line
=
[]
if
prefix
is
not
None
:
line_len
=
len
(
prefix
)
-
1
else
:
line_len
=
len
(
indent
)
-
1
for
part
in
parts
:
if
line_len
+
1
+
len
(
part
)
>
text_width
and
line
:
lines
.
append
(
indent
+
' '
.
join
(
line
))
line
=
[]
line_len
=
len
(
indent
)
-
1
line
.
append
(
part
)
line_len
+=
len
(
part
)
+
1
if
line
:
lines
.
append
(
indent
+
' '
.
join
(
line
))
if
prefix
is
not
None
:
lines
[
0
]
=
lines
[
0
][
len
(
indent
):]
return
lines
# if prog is short, follow it with optionals or positionals
if
len
(
prefix
)
+
len
(
prog
)
<=
0.75
*
text_width
:
indent
=
' '
*
(
len
(
prefix
)
+
len
(
prog
)
+
1
)
if
opt_parts
:
lines
=
get_lines
([
prog
]
+
opt_parts
,
indent
,
prefix
)
lines
.
extend
(
get_lines
(
pos_parts
,
indent
))
elif
pos_parts
:
lines
=
get_lines
([
prog
]
+
pos_parts
,
indent
,
prefix
)
else
:
lines
=
[
prog
]
# if prog is long, put it on its own line
else
:
indent
=
' '
*
len
(
prefix
)
parts
=
opt_parts
+
pos_parts
lines
=
get_lines
(
parts
,
indent
)
if
len
(
lines
)
>
1
:
lines
=
[]
lines
.
extend
(
get_lines
(
opt_parts
,
indent
))
lines
.
extend
(
get_lines
(
pos_parts
,
indent
))
lines
=
[
prog
]
+
lines
# join lines into usage
usage
=
'
\n
'
.
join
(
lines
)
# prefix with 'usage:'
return
'%s%s
\n\n
'
%
(
prefix
,
usage
)
def
_format_actions_usage
(
self
,
actions
,
groups
):
# find group indices and identify actions in groups
group_actions
=
set
()
inserts
=
{}
for
group
in
groups
:
try
:
start
=
actions
.
index
(
group
.
_group_actions
[
0
])
except
ValueError
:
continue
else
:
end
=
start
+
len
(
group
.
_group_actions
)
if
actions
[
start
:
end
]
==
group
.
_group_actions
:
for
action
in
group
.
_group_actions
:
group_actions
.
add
(
action
)
if
not
group
.
required
:
if
start
in
inserts
:
inserts
[
start
]
+=
' ['
else
:
inserts
[
start
]
=
'['
inserts
[
end
]
=
']'
else
:
if
start
in
inserts
:
inserts
[
start
]
+=
' ('
else
:
inserts
[
start
]
=
'('
inserts
[
end
]
=
')'
for
i
in
range
(
start
+
1
,
end
):
inserts
[
i
]
=
'|'
# collect all actions format strings
parts
=
[]
for
i
,
action
in
enumerate
(
actions
):
# suppressed arguments are marked with None
# remove | separators for suppressed arguments
if
action
.
help
is
SUPPRESS
:
parts
.
append
(
None
)
if
inserts
.
get
(
i
)
==
'|'
:
inserts
.
pop
(
i
)
elif
inserts
.
get
(
i
+
1
)
==
'|'
:
inserts
.
pop
(
i
+
1
)
# produce all arg strings
elif
not
action
.
option_strings
:
part
=
self
.
_format_args
(
action
,
action
.
dest
)
# if it's in a group, strip the outer []
if
action
in
group_actions
:
if
part
[
0
]
==
'['
and
part
[
-
1
]
==
']'
:
part
=
part
[
1
:
-
1
]
# add the action string to the list
parts
.
append
(
part
)
# produce the first way to invoke the option in brackets
else
:
option_string
=
action
.
option_strings
[
0
]
# if the Optional doesn't take a value, format is:
# -s or --long
if
action
.
nargs
==
0
:
part
=
'%s'
%
option_string
# if the Optional takes a value, format is:
# -s ARGS or --long ARGS
else
:
default
=
action
.
dest
.
upper
()
args_string
=
self
.
_format_args
(
action
,
default
)
part
=
'%s %s'
%
(
option_string
,
args_string
)
# make it look optional if it's not required or in a group
if
not
action
.
required
and
action
not
in
group_actions
:
part
=
'[%s]'
%
part
# add the action string to the list
parts
.
append
(
part
)
# insert things at the necessary indices
for
i
in
sorted
(
inserts
,
reverse
=
True
):
parts
[
i
:
i
]
=
[
inserts
[
i
]]
# join all the action items with spaces
text
=
' '
.
join
([
item
for
item
in
parts
if
item
is
not
None
])
# clean up separators for mutually exclusive groups
open
=
r
'[\[(]'
close
=
r
'[\])]'
text
=
_re
.
sub
(
r
'(%s) '
%
open
,
r
'\1'
,
text
)
text
=
_re
.
sub
(
r
' (%s)'
%
close
,
r
'\1'
,
text
)
text
=
_re
.
sub
(
r
'%s *%s'
%
(
open
,
close
),
r
''
,
text
)
text
=
_re
.
sub
(
r
'\(([^|]*)\)'
,
r
'\1'
,
text
)
text
=
text
.
strip
()
# return the text
return
text
def
_format_text
(
self
,
text
):
if
'%(prog)'
in
text
:
text
=
text
%
dict
(
prog
=
self
.
_prog
)
text_width
=
max
(
self
.
_width
-
self
.
_current_indent
,
11
)
indent
=
' '
*
self
.
_current_indent
return
self
.
_fill_text
(
text
,
text_width
,
indent
)
+
'
\n\n
'
def
_format_action
(
self
,
action
):
# determine the required width and the entry label
help_position
=
min
(
self
.
_action_max_length
+
2
,
self
.
_max_help_position
)
help_width
=
max
(
self
.
_width
-
help_position
,
11
)
action_width
=
help_position
-
self
.
_current_indent
-
2
action_header
=
self
.
_format_action_invocation
(
action
)
# ho nelp; start on same line and add a final newline
if
not
action
.
help
:
tup
=
self
.
_current_indent
,
''
,
action_header
action_header
=
'%*s%s
\n
'
%
tup
# short action name; start on the same line and pad two spaces
elif
len
(
action_header
)
<=
action_width
:
tup
=
self
.
_current_indent
,
''
,
action_width
,
action_header
action_header
=
'%*s%-*s '
%
tup
indent_first
=
0
# long action name; start on the next line
else
:
tup
=
self
.
_current_indent
,
''
,
action_header
action_header
=
'%*s%s
\n
'
%
tup
indent_first
=
help_position
# collect the pieces of the action help
parts
=
[
action_header
]
# if there was help for the action, add lines of help text
if
action
.
help
:
help_text
=
self
.
_expand_help
(
action
)
help_lines
=
self
.
_split_lines
(
help_text
,
help_width
)
parts
.
append
(
'%*s%s
\n
'
%
(
indent_first
,
''
,
help_lines
[
0
]))
for
line
in
help_lines
[
1
:]:
parts
.
append
(
'%*s%s
\n
'
%
(
help_position
,
''
,
line
))
# or add a newline if the description doesn't end with one
elif
not
action_header
.
endswith
(
'
\n
'
):
parts
.
append
(
'
\n
'
)
# if there are any sub-actions, add their help as well
for
subaction
in
self
.
_iter_indented_subactions
(
action
):
parts
.
append
(
self
.
_format_action
(
subaction
))
# return a single string
return
self
.
_join_parts
(
parts
)
def
_format_action_invocation
(
self
,
action
):
if
not
action
.
option_strings
:
metavar
,
=
self
.
_metavar_formatter
(
action
,
action
.
dest
)(
1
)
return
metavar
else
:
parts
=
[]
# if the Optional doesn't take a value, format is:
# -s, --long
if
action
.
nargs
==
0
:
parts
.
extend
(
action
.
option_strings
)
# if the Optional takes a value, format is:
# -s ARGS, --long ARGS
else
:
default
=
action
.
dest
.
upper
()
args_string
=
self
.
_format_args
(
action
,
default
)
for
option_string
in
action
.
option_strings
:
parts
.
append
(
'%s %s'
%
(
option_string
,
args_string
))
return
', '
.
join
(
parts
)
def
_metavar_formatter
(
self
,
action
,
default_metavar
):
if
action
.
metavar
is
not
None
:
result
=
action
.
metavar
elif
action
.
choices
is
not
None
:
choice_strs
=
[
str
(
choice
)
for
choice
in
action
.
choices
]
result
=
'{%s}'
%
','
.
join
(
choice_strs
)
else
:
result
=
default_metavar
def
format
(
tuple_size
):
if
isinstance
(
result
,
tuple
):
return
result
else
:
return
(
result
,
)
*
tuple_size
return
format
def
_format_args
(
self
,
action
,
default_metavar
):
get_metavar
=
self
.
_metavar_formatter
(
action
,
default_metavar
)
if
action
.
nargs
is
None
:
result
=
'%s'
%
get_metavar
(
1
)
elif
action
.
nargs
==
OPTIONAL
:
result
=
'[%s]'
%
get_metavar
(
1
)
elif
action
.
nargs
==
ZERO_OR_MORE
:
result
=
'[%s [%s ...]]'
%
get_metavar
(
2
)
elif
action
.
nargs
==
ONE_OR_MORE
:
result
=
'%s [%s ...]'
%
get_metavar
(
2
)
elif
action
.
nargs
==
REMAINDER
:
result
=
'...'
elif
action
.
nargs
==
PARSER
:
result
=
'%s ...'
%
get_metavar
(
1
)
else
:
formats
=
[
'%s'
for
_
in
range
(
action
.
nargs
)]
result
=
' '
.
join
(
formats
)
%
get_metavar
(
action
.
nargs
)
return
result
def
_expand_help
(
self
,
action
):
params
=
dict
(
vars
(
action
),
prog
=
self
.
_prog
)
for
name
in
list
(
params
):
if
params
[
name
]
is
SUPPRESS
:
del
params
[
name
]
for
name
in
list
(
params
):
if
hasattr
(
params
[
name
],
'__name__'
):
params
[
name
]
=
params
[
name
].
__name__
if
params
.
get
(
'choices'
)
is
not
None
:
choices_str
=
', '
.
join
([
str
(
c
)
for
c
in
params
[
'choices'
]])
params
[
'choices'
]
=
choices_str