def test_single_string(self):
param = Parameter(diz=dict(name='rast', required='yes',
multiple='no', type='string'))
# set private attributes to skip the check function
param._value = 'elev'
param._rawvalue = 'elev'
self.assertEqual("rast=elev", param.get_bash())
def test_single_string(self):
param = Parameter(
diz=dict(name="rast", required="yes", multiple="no", type="string")
)
# set private attributes to skip the check function
param._value = "elev"
param._rawvalue = "elev"
self.assertEqual("rast=elev", param.get_bash())
def test_multiple_float_double(self):
for ptype in ('float', 'double'):
param = Parameter(diz=dict(name='number', required='yes',
multiple='yes', type=ptype))
value = (1.4, 2.3)
self.assertTupleEqual((list(value), value),
_check_value(param, value))
value = (1, 2)
self.assertTupleEqual(([float(v) for v in value], value),
_check_value(param, value))
value = ("1", "2")
self.assertTupleEqual(([float(v) for v in value], value),
_check_value(param, value))
value = ("1.4", "2.3")
self.assertTupleEqual(([float(v) for v in value], value),
_check_value(param, value))
value = 1.
self.assertTupleEqual(([value, ], value),
_check_value(param, value))
value = 1
self.assertTupleEqual(([value, ], value),
_check_value(param, value))
# test errors
with self.assertRaises(ValueError):
_check_value(param, "elev")
with self.assertRaises(ValueError):
_check_value(param, ("elev", "slope", "aspect"))
def test_range_float_double(self):
for ptype in ("float", "double"):
param = Parameter(
diz=dict(
name="int_number",
required="yes",
multiple="no",
type=ptype,
values=[
"0.0-2.5",
],
)
)
value = 1
self.assertTupleEqual((float(value), value), _check_value(param, value))
value = 1.2
self.assertTupleEqual((value, value), _check_value(param, value))
value = "0"
self.assertTupleEqual((float(value), value), _check_value(param, value))
value = "2.5"
self.assertTupleEqual((float(value), value), _check_value(param, value))
# test errors
with self.assertRaises(ValueError):
_check_value(param, "elev")
with self.assertRaises(TypeError):
_check_value(param, (1.0, 2.0))
with self.assertRaises(ValueError):
_check_value(param, -1.0)
with self.assertRaises(ValueError):
_check_value(param, 2.6)
def test_keydescvalues(self):
for ptype in ("integer", "float"):
param = Parameter(
diz=dict(
name="int_number",
required="yes",
multiple="yes",
keydesc=("range", "(min, max)"),
type="integer",
)
)
value = (1, 2)
self.assertTupleEqual(
(
[
value,
],
value,
),
_check_value(param, value),
)
value = [(1, 2), (2, 3)]
self.assertTupleEqual((value, value), _check_value(param, value))
with self.assertRaises(TypeError):
_check_value(param, 1)
def test_range_integer(self):
param = Parameter(
diz=dict(
name="int_number",
required="yes",
multiple="no",
type="integer",
values=[
"0-10",
],
)
)
value = 1
self.assertTupleEqual((value, value), _check_value(param, value))
value = 0
self.assertTupleEqual((value, value), _check_value(param, value))
value = 10
self.assertTupleEqual((value, value), _check_value(param, value))
value = 1.2
self.assertTupleEqual((int(value), value), _check_value(param, value))
value = "1"
self.assertTupleEqual((int(value), value), _check_value(param, value))
# test errors
with self.assertRaises(ValueError):
_check_value(param, "1.")
with self.assertRaises(ValueError):
_check_value(param, "elev")
with self.assertRaises(TypeError):
_check_value(param, (1, 2))
with self.assertRaises(ValueError):
_check_value(param, -1)
with self.assertRaises(ValueError):
_check_value(param, 11)
def test_choice_integer(self):
param = Parameter(
diz=dict(
name="int_number",
required="yes",
multiple="no",
type="integer",
values=[2, 4, 6, 8],
)
)
value = 4
self.assertTupleEqual((value, value), _check_value(param, value))
value = 2
self.assertTupleEqual((int(value), value), _check_value(param, value))
value = "8"
self.assertTupleEqual((int(value), value), _check_value(param, value))
# test errors
with self.assertRaises(ValueError):
_check_value(param, "2.")
with self.assertRaises(ValueError):
_check_value(param, "elev")
with self.assertRaises(TypeError):
_check_value(param, (1, 2))
with self.assertRaises(ValueError):
_check_value(param, 3)
def test_multiple_strings(self):
param = Parameter(
diz=dict(name="rastnames", required="yes", multiple="yes", type="string")
)
value = ["elev", "slope", "aspect"]
self.assertTupleEqual((value, value), _check_value(param, value))
value = ("elev", "slope", "aspect")
self.assertTupleEqual((list(value), value), _check_value(param, value))
value = ["1.3", "2.3", "4.5"]
self.assertTupleEqual((value, value), _check_value(param, value))
value = [1.3, 2.3, 4.5]
self.assertTupleEqual(
([str(v) for v in value], value), _check_value(param, value)
)
value = (1, 2, 3)
self.assertTupleEqual(
([str(v) for v in value], value), _check_value(param, value)
)
value = "elev"
self.assertTupleEqual(
(
[
value,
],
value,
),
_check_value(param, value),
)
# test errors
with self.assertRaises(ValueError):
_check_value(param, ({}, {}, {}))
def test_multiple_integer(self):
param = Parameter(diz=dict(name='int_number', required='yes',
multiple='yes', type='integer'))
value = (1, 2)
#import ipdb; ipdb.set_trace()
self.assertTupleEqual((list(value), value), _check_value(param, value))
value = (1.2, 2.3)
self.assertTupleEqual(([int(v) for v in value], value),
_check_value(param, value))
value = ("1", "2")
self.assertTupleEqual(([int(v) for v in value], value),
_check_value(param, value))
value = 1
self.assertTupleEqual(([1, ], value), _check_value(param, value))
value = 1.2
self.assertTupleEqual(([int(value), ], value),
_check_value(param, value))
value = "1"
self.assertTupleEqual(([int(value), ], value),
_check_value(param, value))
# test errors
with self.assertRaises(ValueError):
_check_value(param, "elev")
with self.assertRaises(ValueError):
_check_value(param, ("elev", "slope", "aspect"))
def test_range_float_double(self):
for ptype in ('float', 'double'):
param = Parameter(diz=dict(name='int_number',
required='yes',
multiple='no',
type=ptype,
values=[
"0.0-2.5",
]))
value = 1
self.assertTupleEqual((float(value), value),
_check_value(param, value))
value = 1.2
self.assertTupleEqual((value, value), _check_value(param, value))
value = "0"
self.assertTupleEqual((float(value), value),
_check_value(param, value))
value = "2.5"
self.assertTupleEqual((float(value), value),
_check_value(param, value))
# test errors
with self.assertRaises(ValueError):
_check_value(param, "elev")
with self.assertRaises(TypeError):
_check_value(param, (1., 2.))
with self.assertRaises(ValueError):
_check_value(param, -1.)
with self.assertRaises(ValueError):
_check_value(param, 2.6)
def test_multiple_strings(self):
param = Parameter(diz=dict(name='rast', required='yes',
multiple='yes', type='string'))
# set private attributes to skip the check function
param._value = ['elev', 'asp', 'slp']
param._rawvalue = ['elev', 'asp', 'slp']
self.assertEqual("rast=elev,asp,slp", param.get_bash())
param._value = ['elev', ]
param._rawvalue = 'elev'
self.assertEqual("rast=elev", param.get_bash())
def test_single_float_double(self):
for ptype in ('float', 'double'):
param = Parameter(diz=dict(name='number', required='yes',
multiple='no', type=ptype))
# set private attributes to skip the check function
param._value = 1.0
param._rawvalue = 1.0
self.assertEqual("number=1.0", param.get_bash())
param._value = 1.0
param._rawvalue = "1."
self.assertEqual("number=1.", param.get_bash())
def test_single_float_double(self):
for ptype in ("float", "double"):
param = Parameter(
diz=dict(name="number", required="yes", multiple="no", type=ptype)
)
# set private attributes to skip the check function
param._value = 1.0
param._rawvalue = 1.0
self.assertEqual("number=1.0", param.get_bash())
param._value = 1.0
param._rawvalue = "1."
self.assertEqual("number=1.", param.get_bash())
def test_multiple_strings(self):
param = Parameter(
diz=dict(name="rast", required="yes", multiple="yes", type="string")
)
# set private attributes to skip the check function
param._value = ["elev", "asp", "slp"]
param._rawvalue = ["elev", "asp", "slp"]
self.assertEqual("rast=elev,asp,slp", param.get_bash())
param._value = [
"elev",
]
param._rawvalue = "elev"
self.assertEqual("rast=elev", param.get_bash())
def test_single_all(self):
param = Parameter(diz=dict(name='int_number', required='yes',
multiple='no', type='all'))
value = 1
self.assertTupleEqual((value, value), _check_value(param, value))
value = 1.2
self.assertTupleEqual((value, value), _check_value(param, value))
value = "elev"
self.assertTupleEqual((value, value), _check_value(param, value))
# test errors
with self.assertRaises(TypeError):
_check_value(param, (1, 2))
def test_keydescvalues(self):
for ptype in ('integer', 'float'):
param = Parameter(diz=dict(name='int_number', required='yes',
multiple='yes',
keydesc=('range', '(min, max)'),
type='integer'))
value = (1, 2)
self.assertTupleEqual(([value, ], value),
_check_value(param, value))
value = [(1, 2), (2, 3)]
self.assertTupleEqual((value, value), _check_value(param, value))
with self.assertRaises(TypeError):
_check_value(param, 1)
def test_single_string_file(self):
for ptype in ("string", "file"):
param = Parameter(
diz=dict(name="name", required="yes", multiple="no", type=ptype)
)
value = "elev"
self.assertTupleEqual((value, value), _check_value(param, value))
value = 10
self.assertTupleEqual((str(value), value), _check_value(param, value))
value = 12.5
self.assertTupleEqual((str(value), value), _check_value(param, value))
# test errors
with self.assertRaises(TypeError):
_check_value(param, ("abc", "def"))
def test_single_string_file(self):
for ptype in ('string', 'file'):
param = Parameter(diz=dict(name='name', required='yes',
multiple='no', type=ptype))
value = u'elev'
self.assertTupleEqual((value, value), _check_value(param, value))
value = 10
self.assertTupleEqual((str(value), value),
_check_value(param, value))
value = 12.5
self.assertTupleEqual((str(value), value),
_check_value(param, value))
# test errors
with self.assertRaises(TypeError):
_check_value(param, ('abc', 'def'))
def test_choice_string(self):
values = ["elev", "asp", "slp"]
param = Parameter(diz=dict(name='rastname', required='yes',
multiple='no', type='string',
values=values))
value = "asp"
self.assertTupleEqual((value, value), _check_value(param, value))
# test errors
with self.assertRaises(ValueError):
_check_value(param, "2")
with self.assertRaises(ValueError):
_check_value(param, "2.")
with self.assertRaises(TypeError):
_check_value(param, (1, 2))
with self.assertRaises(ValueError):
_check_value(param, "elevation")
def test_multiple_strings(self):
param = Parameter(diz=dict(name='rastnames', required='yes',
multiple='yes', type='string'))
value = ['elev', 'slope', 'aspect']
self.assertTupleEqual((value, value), _check_value(param, value))
value = ('elev', 'slope', 'aspect')
self.assertTupleEqual((list(value), value), _check_value(param, value))
value = ['1.3', '2.3', '4.5']
self.assertTupleEqual((value, value), _check_value(param, value))
value = [1.3, 2.3, 4.5]
self.assertTupleEqual(([str(v) for v in value], value),
_check_value(param, value))
value = (1, 2, 3)
self.assertTupleEqual(([str(v) for v in value], value),
_check_value(param, value))
value = 'elev'
self.assertTupleEqual(([value, ], value), _check_value(param, value))
# test errors
with self.assertRaises(ValueError):
_check_value(param, ({}, {}, {}))
def test_keydescvalues(self):
param = Parameter(diz=dict(name='range', required='yes',
multiple='yes',
keydesc=('range', '(min, max)'),
type='integer'))
# set private attributes to skip the check function
param._value = [(1., 2.), ]
param._rawvalue = (1., 2.)
self.assertEqual("range=1.0,2.0", param.get_bash())
param._value = [(1., 2.), (3., 4.)]
param._rawvalue = [(1., 2.), (3., 4.)]
self.assertEqual("range=1.0,2.0,3.0,4.0", param.get_bash())
param._value = [(1., 2.), (3., 4.)]
param._rawvalue = [('1.0', '2.00'), ('3.000', '4.0000')]
self.assertEqual("range=1.0,2.00,3.000,4.0000", param.get_bash())
with self.assertRaises(TypeError):
_check_value(param, 1)
def test_keydescvalues(self):
param = Parameter(
diz=dict(
name="range",
required="yes",
multiple="yes",
keydesc=("range", "(min, max)"),
type="integer",
)
)
# set private attributes to skip the check function
param._value = [
(1.0, 2.0),
]
param._rawvalue = (1.0, 2.0)
self.assertEqual("range=1.0,2.0", param.get_bash())
param._value = [(1.0, 2.0), (3.0, 4.0)]
param._rawvalue = [(1.0, 2.0), (3.0, 4.0)]
self.assertEqual("range=1.0,2.0,3.0,4.0", param.get_bash())
param._value = [(1.0, 2.0), (3.0, 4.0)]
param._rawvalue = [("1.0", "2.00"), ("3.000", "4.0000")]
self.assertEqual("range=1.0,2.00,3.000,4.0000", param.get_bash())
with self.assertRaises(TypeError):
_check_value(param, 1)
def __init__(self, cmd, *args, **kargs):
if isinstance(cmd, unicode):
self.name = str(cmd)
elif isinstance(cmd, str):
self.name = cmd
else:
raise GrassError(
"Problem initializing the module {s}".format(s=cmd))
try:
# call the command with --interface-description
get_cmd_xml = Popen([cmd, "--interface-description"], stdout=PIPE)
except OSError as e:
print("OSError error({0}): {1}".format(e.errno, e.strerror))
str_err = "Error running: `%s --interface-description`."
raise GrassError(str_err % self.name)
# get the xml of the module
self.xml = get_cmd_xml.communicate()[0]
# transform and parse the xml into an Element class:
# http://docs.python.org/library/xml.etree.elementtree.html
tree = fromstring(self.xml)
for e in tree:
if e.tag not in ('parameter', 'flag'):
self.__setattr__(e.tag, GETFROMTAG[e.tag](e))
#
# extract parameters from the xml
#
self.params_list = [Parameter(p) for p in tree.findall("parameter")]
self.inputs = TypeDict(Parameter)
self.outputs = TypeDict(Parameter)
self.required = []
# Insert parameters into input/output and required
for par in self.params_list:
if par.input:
self.inputs[par.name] = par
else:
self.outputs[par.name] = par
if par.required:
self.required.append(par.name)
#
# extract flags from the xml
#
flags_list = [Flag(f) for f in tree.findall("flag")]
self.flags = TypeDict(Flag)
for flag in flags_list:
self.flags[flag.name] = flag
#
# Add new attributes to the class
#
self.run_ = True
self.finish_ = True
self.env_ = None
self.stdin_ = None
self.stdin = None
self.stdout_ = None
self.stderr_ = None
diz = {
'name': 'stdin',
'required': False,
'multiple': False,
'type': 'all',
'value': None
}
self.inputs['stdin'] = Parameter(diz=diz)
diz['name'] = 'stdout'
self.outputs['stdout'] = Parameter(diz=diz)
diz['name'] = 'stderr'
self.outputs['stderr'] = Parameter(diz=diz)
self.popen = None
self.time = None
if args or kargs:
self.__call__(*args, **kargs)
self.__call__.__func__.__doc__ = self.__doc__
