def setUp(self):
self.domain = AllowedRangeCollection(
AllowedRange(None, -5.0, 'open'),
AllowedRange(6.0, None, spacing=3.0),
AllowedEnum(xrange(-4, 0)),
AllowedEnum(range(0, 6, 2)),
)
self.accepted = ['-inf', -100., -3, 2, 6, 300]
self.rejected = ['nan', '+inf', 7, 3, -0.5, -5]
def setUp(self):
try:
# Python 2
xrange
except NameError:
# Python 3, xrange is now named range
xrange = range
self.domain = AllowedRangeCollection(
AllowedRange(None, -5.0, 'open'),
AllowedRange(6.0, None, spacing=3.0),
AllowedEnum(xrange(-4, 0)),
AllowedEnum(range(0, 6, 2)),
)
self.accepted = ['-inf', -100., -3, 2, 6, 300]
self.rejected = ['nan', '+inf', 7, 3, -0.5, -5]
def setUp(self):
self.domain = AllowedRange(time(9, 30, 0, 0),
'16:30',
'closed',
spacing='PT1H',
dtype=time)
self.accepted = ['09:30', '10:30', '15:30', '16:30']
self.rejected = ['09:00', '10:00', '16:25', '16:35']
def setUp(self):
self.domain = AllowedRange(date(2014, 1, 1),
'2014-01-21',
'closed',
spacing='P5D',
dtype=date)
self.accepted = [
'2014-01-01', '2014-01-06', '2014-01-16', '2014-01-21'
]
self.rejected = ['2013-12-31', '2014-01-10', '2014-01-31']
def setUp(self):
self.domain = AllowedRange('-P1DT1H', 'P1M0DT30M', dtype=Duration)
self.accepted = [
Duration.parse('-P1DT1H'),
'P0D',
'P1M0DT30M',
]
self.rejected = [
Duration.parse('-P2DT18H'),
'P1Y',
]
def setUp(self):
self.domain = AllowedRange('2014-02-01',
'2014-03-01',
'open',
dtype=Date)
self.accepted = [
'2014-02-15',
]
self.rejected = [
'2014-02-01',
Date.parse('2014-03-01'),
Date.parse('2014-01-02'),
]
def setUp(self):
self.domain = AllowedRange('2014-02-01T09:30:21Z',
'2014-03-01T18:20:15Z',
dtype=DateTime)
self.accepted = [
'2014-02-01T09:30:21Z',
'2014-02-15T00:00:00Z',
'2014-03-01T18:20:15Z',
]
self.rejected = [
'2014-01-01T00:00:00Z',
DateTime.parse('2014-04-01T00:00:00Z'),
]
def setUp(self):
self.domain = AllowedRange(timedelta(0, 3600, 0),
'PT5H',
'open-closed',
spacing='PT1H',
dtype=timedelta)
self.accepted = [
Duration.parse('PT2H'),
timedelta(0, 3 * 3600, 0),
'PT4H',
'PT5H',
'PT2H0.000001S',
]
self.rejected = [
'PT30M',
'PT1H',
'PT2H30M',
]
def setUp(self):
self.domain = AllowedRange(datetime(2014, 1, 1, 10, 30, 0, 0,
DateTime.UTC),
'2014-01-10T10:30Z',
'closed',
spacing='P1D',
dtype=datetime)
self.accepted = [
'2014-01-01T10:30Z',
'2014-01-02T10:30Z',
'2014-01-05T10:30Z',
'2014-01-07T10:30Z',
'2014-01-09T10:30Z',
'2014-01-10T10:30Z',
]
self.rejected = [
'2013-12-31T10:30Z',
'2014-01-01T11:00Z',
'2014-01-05T00:00Z',
'2014-01-11T10:30Z',
]
def setUp(self):
self.domain = AllowedRange(0, 10, spacing='2', dtype=int)
self.accepted = [4, 0, 10]
self.rejected = [5, -1, 12]
def setUp(self):
self.domain = AllowedRange(0.0, 1.0, spacing='0.1')
self.accepted = [0.5, 0.0, 1.0]
self.rejected = [0.55, -1.0, 2.0]
def setUp(self):
self.domain = AllowedRange(0.0, 1.0, dtype=float)
self.accepted = [0.5, 0.0, 1.0]
self.rejected = [-1.0, 2.0]
class TestProcess00(Component):
""" Test identity process (the outputs are copies of the inputs)
demonstrating various features of the literal data inputs and outputs.
"""
implements(ProcessInterface)
identifier = "TC00:identity:literal"
title = "Test Case 00: Literal data identity."
metadata = {"test-metadata": "http://www.metadata.com/test-metadata"}
profiles = ["test_profile"]
inputs = [
("input00", str), # mandatory minimal string input
("input01",
LiteralData(
'TC00:input01',
String,
optional=True,
abstract="Optional simple string input.",
)),
("input02",
LiteralData(
'TC00:input02',
str,
optional=True,
abstract="Optional enumerated string input with default value.",
allowed_values=('low', 'medium', 'high'),
default='medium',
)),
("input03",
LiteralData(
'TC00:input03',
float,
optional=True,
title="Distance",
abstract=
("Optional restricted float input with default value and simple "
"UOM conversion."),
allowed_values=AllowedRange(0, 2, dtype=float),
default=0,
uoms=[
('m', 1.0),
('mm', 1e-3),
('cm', 1e-2),
('dm', 1e-1),
('yd', 0.9144),
('ft', 0.3048),
('in', 0.0254),
('km', 1000.0),
('mi', 1609.344),
('NM', 1852.0),
],
)),
("input04",
LiteralData(
'TC00:input04',
float,
optional=True,
title="Temperature",
abstract=(
"Optional restricted float input with default value and "
"advanced UOM conversion."),
allowed_values=AllowedRange(0, None, dtype=float),
default=298.15,
uoms=(('K', 1.0), UnitLinear('C', 1.0, 273.15),
UnitLinear('F', 5.0 / 9.0, 459.67 * 5.0 / 9.0)),
)),
]
outputs = [
("output00", str), # minimal string output
(
"output01",
LiteralData(
# NOTE: Outputs can be optional and have default value too.
'TC00:output01',
String,
optional=True,
default='n/a',
abstract="Simple string output.",
)),
("output02",
LiteralData(
'TC00:output02',
str,
abstract="Enumerated string output.",
allowed_values=('low', 'medium', 'high'),
default='medium',
)),
("output03",
LiteralData(
'TC00:output03',
float,
title="Distance",
abstract="Restricted float output with UOM conversion.",
allowed_values=AllowedRange(0, 1, dtype=float),
uoms=[
('m', 1.0),
('mm', 1e-3),
('cm', 1e-2),
('dm', 1e-1),
('yd', 0.9144),
('ft', 0.3048),
('in', 0.0254),
('km', 1000.0),
('mi', 1609.344),
('NM', 1852.0),
],
)),
("output04",
LiteralData(
'TC00:output04',
float,
title="Temperature",
abstract="Restricted float output advanced UOM conversion.",
allowed_values=AllowedRange(0, None, dtype=float),
uoms=(
('K', 1.0),
UnitLinear('C', 1.0, 273.15),
UnitLinear('F', 5.0 / 9.0, 459.67 * 5.0 / 9.0),
),
)),
]
def execute(self, **inputs):
""" WPS Process execute handler. """
return {
'output00': inputs['input00'],
'output01': inputs.get('input01'),
'output02': inputs['input02'],
'output03': inputs['input03'],
'output04': inputs['input04'],
}
def setUp(self):
self.domain = AllowedRange(0, 10, 'open', dtype=Integer)
self.accepted = [5]
self.rejected = [0, 10, -1, 12]
def setUp(self):
self.domain = AllowedRange(0, 10, dtype=Integer)
self.accepted = [0, 5, 10]
self.rejected = [-1, 12]
def setUp(self):
self.domain = AllowedRange(0.0, 1.0, 'closed-open')
self.accepted = [0.5, 0.0]
self.rejected = [1.0, -1.0, 2.0]
def setUp(self):
self.domain = AllowedRange(0.0, None)
self.accepted = ['+inf', 0.5, 0.0, 1.0, 2.0]
self.rejected = [-1.0]
def setUp(self):
self.domain = AllowedRange(None, 1.0)
self.accepted = ['-inf', -1.0, 0.5, 0.0, 1.0]
self.rejected = [2.0]
def setUp(self):
self.domain = AllowedRange('10:00', '15:30', 'open-closed', dtype=Time)
self.accepted = ['12:15', '15:30']
self.rejected = [Time.parse('09:00'), '10:00', '18:12']
class TestProcess03(Component):
""" Test process generating binary complex data output. """
implements(ProcessInterface)
identifier = "TC03:image_generator:complex"
title = "Test Case 03: Complex data binary output with format selection."
description = (
"Test process generating binary complex data output (an image)."
)
metadata = {"test-metadata": "http://www.metadata.com/test-metadata"}
profiles = ["test_profile"]
inputs = [
("method", LiteralData(
'TC03:method', str, optional=True,
title="Complex data output passing method.",
abstract=(
"This option controls the method how the complex data output "
"payload is passed from process code."
),
allowed_values=('in-memory-buffer', 'file'), default='file',
)),
("seed", LiteralData(
'TC03:seed', int, optional=True, title="Random generator seed.",
abstract=(
"Optional random generator seed that can be used to obtain "
"reproducible random-generated result."
),
allowed_values=AllowedRange(0, None, dtype=int),
)),
]
outputs = [
("output", ComplexData(
'TC03:output00', title="Test case #02: Complex output #00",
abstract="Binary complex data output (random-generated image).",
formats=(
FormatBinaryRaw('image/png'),
FormatBinaryBase64('image/png'),
FormatBinaryRaw('image/jpeg'),
FormatBinaryBase64('image/jpeg'),
FormatBinaryRaw('image/tiff'),
FormatBinaryBase64('image/tiff'),
)
)),
]
# NOTE:
# The output complex data format has to be handled by the processes
# itself and the format selection has to be passed to the 'execute'
# subroutine. The output complex data format selection is passed
# to the process as an additional input argument - a simple dictionary
# with the 'mime_type', 'encoding', 'schema', and 'as_reference' keywords.
# In case no format being selected by the user this format selection
# is set to the default format. The name of the input argument holding
# the is controlled by the process output definition.
@staticmethod
def execute(method, seed, output):
# size of the output image
size_x, size_y = (768, 512)
# output format selection
if output['mime_type'] == "image/png":
extension = ".png"
driver = gdal.GetDriverByName("PNG")
options = []
elif output['mime_type'] == "image/jpeg":
extension = ".jpg"
driver = gdal.GetDriverByName("JPEG")
options = []
elif output['mime_type'] == "image/tiff":
extension = ".tif"
driver = gdal.GetDriverByName("GTiff")
options = ["TILED=YES", "COMPRESS=DEFLATE", "PHOTOMETRIC=RGB"]
else:
ExecuteError("Unexpected output format received! %r" % output)
# generate a random in-memory GDAL dataset
mem_driver = gdal.GetDriverByName("MEM")
mem_ds = mem_driver.Create("", size_x, size_y, 3, gdal.GDT_Byte)
random_state = RandomState(seed)
for i in xrange(3):
mem_ds.GetRasterBand(i+1).WriteArray(
(256.0 * random_state.rand(size_y, size_x)).astype('uint8')
)
# convert in-memory dataset to the desired output
tmp_filename = os.path.join("/tmp", str(uuid.uuid4()) + extension)
output_filename = "test03_binary_complex" + extension
try:
driver.CreateCopy(tmp_filename, mem_ds, 0, options)
del mem_ds
if method == 'file':
# Return object as a temporary Complex Data File.
# None that the object holds the format attributes!
# The 'filename' parameter sets the raw output
# 'Content-Disposition: filename=' HTTP header.
return CDFile(tmp_filename, filename=output_filename, **output)
elif method == 'in-memory-buffer':
# Return object as an in-memory Complex Data Buffer.
# None that the object holds the format attributes!
# The 'filename' parameter sets the raw output
# 'Content-Disposition: filename=' HTTP header.
with open(tmp_filename, 'rb') as fid:
_output = CDByteBuffer(
fid.read(), filename=output_filename, **output
)
os.remove(tmp_filename)
return _output
except:
# make sure no temporary file is left in case of an exception
if os.path.isfile(tmp_filename):
os.remove(tmp_filename)
raise
