def test_array_slice(self):
"""Test slices applied to a grid."""
dataset = apply_projection(parse_projection("SimpleGrid[1]"),
self.dataset)
np.testing.assert_array_equal(dataset.SimpleGrid.x.data,
self.dataset.SimpleGrid[1].x.data)
np.testing.assert_array_equal(dataset.SimpleGrid.y.data,
self.dataset.SimpleGrid[1].y.data)
np.testing.assert_array_equal(
dataset.SimpleGrid.SimpleGrid.data,
self.dataset.SimpleGrid[1:2].SimpleGrid.data)
def test_array_slice(self):
"""Test slices applied to a grid."""
dataset = apply_projection(
parse_projection("SimpleGrid[1]"), self.dataset)
np.testing.assert_array_equal(
dataset.SimpleGrid.x.data, self.dataset.SimpleGrid[1].x.data)
np.testing.assert_array_equal(
dataset.SimpleGrid.y.data, self.dataset.SimpleGrid[1].y.data)
np.testing.assert_array_equal(
dataset.SimpleGrid.SimpleGrid.data,
self.dataset.SimpleGrid[1:2].SimpleGrid.data)
def test_sequence_projection(self):
"""Test projection slicing on sequences."""
dataset = apply_projection(parse_projection("sequence[2]"),
self.dataset)
np.testing.assert_array_equal(dataset.sequence.data,
VerySimpleSequence.sequence.data[2])
def test_array(self):
"""Test that the grid degenerates into a structure."""
dataset = apply_projection(parse_projection("SimpleGrid.SimpleGrid"),
self.dataset)
self.assertIsInstance(dataset.SimpleGrid, StructureType)
def test_simple_projection_with_index(self):
"""Test simple projections."""
dataset = apply_projection(parse_projection("x[1]"), self.dataset)
np.testing.assert_array_equal(dataset.x.data, [1])
def test_simple_projection(self):
"""Test simple projections."""
dataset = apply_projection(parse_projection("x"), self.dataset)
self.assertEqual(list(dataset.keys()), ["x"])
def test_no_projection(self):
"""Test no projections."""
dataset = apply_projection("", self.dataset)
self.assertEqual(list(dataset.children()), [])
def test_no_projection(self):
"""Test no projections."""
dataset = apply_projection("", self.dataset)
self.assertEqual(list(dataset.children()), [])
def test_structure_projection(self):
"""Test projection slicing on a structure."""
with self.assertRaises(ConstraintExpressionError):
apply_projection(parse_projection("types[0]"), SimpleStructure)
def test_sequence_projection(self):
"""Test projection slicing on sequences."""
dataset = apply_projection(
parse_projection("sequence[2]"), self.dataset)
np.testing.assert_array_equal(
dataset.sequence.data, VerySimpleSequence.sequence.data[2])
def test_array(self):
"""Test that the grid degenerates into a structure."""
dataset = apply_projection(
parse_projection("SimpleGrid.SimpleGrid"), self.dataset)
self.assertIsInstance(dataset.SimpleGrid, StructureType)
def test_simple_projection_with_index(self):
"""Test simple projections."""
dataset = apply_projection(parse_projection("x[1]"), self.dataset)
np.testing.assert_array_equal(
dataset.x.data, [1])
def test_simple_projection(self):
"""Test simple projections."""
dataset = apply_projection(parse_projection("x"), self.dataset)
self.assertEqual(list(dataset.keys()), ["x"])
def test_structure_projection(self):
"""Test projection slicing on a structure."""
with self.assertRaises(ConstraintExpressionError):
apply_projection(parse_projection("types[0]"), SimpleStructure)
def __call__(self, environ, start_response):
# specify that we want the parsed dataset
environ['x-wsgiorg.want_parsed_response'] = True
req = Request(environ)
projection, selection = parse_ce(req.query_string)
# check if there are any functions calls in the request
called = (
any(s for s in selection if FUNCTION.match(s)) or
any(p for p in projection if isinstance(p, string_types)))
# ignore DAS requests and requests without functions
path, response = req.path.rsplit('.', 1)
if response == 'das' or not called:
return self.app(environ, start_response)
# apply selection without any function calls
req.query_string = '&'.join(
s for s in selection if not FUNCTION.match(s))
res = req.get_response(self.app)
# get the dataset
method = getattr(res.app_iter, 'x_wsgiorg_parsed_response', False)
if not method:
raise ServerError("Unable to call server-side function!")
dataset = method(DatasetType)
# apply selection containing server-side functions
selection = (s for s in selection if FUNCTION.match(s))
for expr in selection:
if RELOP.search(expr):
call, op, other = RELOP.split(expr)
op = {
'<': operator.lt,
'>': operator.gt,
'!=': operator.ne,
'=': operator.eq,
'>=': operator.ge,
'<=': operator.le,
'=~': lambda a, b: re.match(b, a),
}[op]
other = ast.literal_eval(other)
else:
call, op, other = expr, operator.eq, 1
# evaluate the function call
sequence = eval_function(dataset, call, self.functions)
# is this an inplace call?
for var in walk(dataset, SequenceType):
if sequence is var:
break
else:
# get the data from the resulting variable, and use it to
# constrain the original dataset
child = list(sequence.children())[0]
data = np.fromiter(child.data, child.dtype)
if data.dtype.char == "S":
valid = np.array(
list(map(lambda v: op(str(v), str(other)), data)),
bool)
else:
valid = op(data, other)
for sequence in walk(dataset, SequenceType):
sequence.data = np.rec.fromrecords(
[tuple(row) for row in sequence],
names=sequence.keys())[valid]
# now apply projection
if projection:
projection = fix_shorthand(projection, dataset)
base = [p for p in projection if not isinstance(p, string_types)]
func = [p for p in projection if isinstance(p, string_types)]
# apply non-function projection
out = apply_projection(base, dataset)
# apply function projection
for call in func:
var = eval_function(dataset, call, self.functions)
for child in walk(var):
parent = reduce(
operator.getitem, [out] + child.id.split('.')[:-1])
if child.name not in parent.keys():
parent[child.name] = child
break
dataset = out
# Return the original response (DDS, DAS, etc.)
path, response = req.path.rsplit('.', 1)
res = BaseHandler.responses[response](dataset)
return res(environ, start_response)
def __call__(self, environ, start_response):
# specify that we want the parsed dataset
environ['x-wsgiorg.want_parsed_response'] = True
req = Request(environ)
original_query = req.query_string
projection, selection = parse_ce(req.query_string)
# apply selection without any function calls
req.query_string = '&'.join(expr for expr in selection if not FUNCTION.match(expr))
res = req.get_response(self.app)
# ignore DAS requests
path, response = req.path.rsplit('.', 1)
if response == 'das':
return self.app(environ, start_response)
# get the dataset
method = getattr(res.app_iter, 'x_wsgiorg_parsed_response', False)
if not method:
environ['QUERY_STRING'] = original_query
return self.app(environ, start_response)
dataset = method(DatasetType)
# apply selection containing server-side functions
selection = (expr for expr in selection if FUNCTION.match(expr))
for expr in selection:
if RELOP.search(expr):
call, op, other = RELOP.split(expr)
op = {
'<' : operator.lt,
'>' : operator.gt,
'!=': operator.ne,
'=' : operator.eq,
'>=': operator.ge,
'<=': operator.le,
'=~': lambda a, b: re.match(b, a),
}[op]
other = ast.literal_eval(other)
else:
call, op, other = expr, operator.eq, 1
# evaluate the function call
sequence = eval_function(dataset, call, self.functions)
# is this an inplace call?
for var in walk(dataset, SequenceType):
if sequence is var:
break
else:
# get the data from the resulting variable, and use it to
# constrain the original dataset
data = np.fromiter(sequence)
print data.shape
valid = op(data, other)
for sequence in walk(dataset, SequenceType):
data = np.asarray(list(sequence), 'O')[valid]
sequence.data = np.asarray(list(sequence), 'O')[valid]
dataset = out
# now apply projection
if projection:
projection = fix_shorthand(projection, dataset)
base = [p for p in projection if not isinstance(p, basestring)]
func = [p for p in projection if isinstance(p, basestring)]
# apply non-function projection
out = apply_projection(base, dataset)
# apply function projection
for call in func:
var = eval_function(dataset, call, self.functions)
for child in walk(var):
parent = reduce(operator.getitem, [out] + child.id.split('.')[:-1])
if child.name not in parent.keys():
parent[child.name] = child
break
dataset = out
# Return the original response (DDS, DAS, etc.)
path, response = req.path.rsplit('.', 1)
res = BaseHandler.responses[response](dataset)
return res(environ, start_response)
def __call__(self, environ, start_response):
# specify that we want the parsed dataset
environ['x-wsgiorg.want_parsed_response'] = True
req = Request(environ)
projection, selection = parse_ce(req.query_string)
# check if there are any functions calls in the request
called = (any(s for s in selection if FUNCTION.match(s))
or any(p for p in projection if isinstance(p, string_types)))
# ignore DAS requests and requests without functions
path, response = req.path.rsplit('.', 1)
if response == 'das' or not called:
return self.app(environ, start_response)
# apply selection without any function calls
req.query_string = '&'.join(s for s in selection
if not FUNCTION.match(s))
res = req.get_response(self.app)
# get the dataset
method = getattr(res.app_iter, 'x_wsgiorg_parsed_response', False)
if not method:
raise ServerError("Unable to call server-side function!")
dataset = method(DatasetType)
# apply selection containing server-side functions
selection = (s for s in selection if FUNCTION.match(s))
for expr in selection:
if RELOP.search(expr):
call, op, other = RELOP.split(expr)
op = {
'<': operator.lt,
'>': operator.gt,
'!=': operator.ne,
'=': operator.eq,
'>=': operator.ge,
'<=': operator.le,
'=~': lambda a, b: re.match(b, a),
}[op]
other = ast.literal_eval(other)
else:
call, op, other = expr, operator.eq, 1
# evaluate the function call
sequence = eval_function(dataset, call, self.functions)
# is this an inplace call?
for var in walk(dataset, SequenceType):
if sequence is var:
break
else:
# get the data from the resulting variable, and use it to
# constrain the original dataset
child = list(sequence.children())[0]
data = np.fromiter(child.data, child.dtype)
if data.dtype.char == "S":
valid = np.array(
list(map(lambda v: op(str(v), str(other)), data)),
bool)
else:
valid = op(data, other)
for sequence in walk(dataset, SequenceType):
sequence.data = np.rec.fromrecords(
[tuple(row) for row in sequence],
names=sequence.keys())[valid]
# now apply projection
if projection:
projection = fix_shorthand(projection, dataset)
base = [p for p in projection if not isinstance(p, string_types)]
func = [p for p in projection if isinstance(p, string_types)]
# apply non-function projection
out = apply_projection(base, dataset)
# apply function projection
for call in func:
var = eval_function(dataset, call, self.functions)
for child in walk(var):
parent = reduce(operator.getitem,
[out] + child.id.split('.')[:-1])
if child.name not in parent.keys():
parent[child.name] = child
break
dataset = out
# Return the original response (DDS, DAS, etc.)
path, response = req.path.rsplit('.', 1)
res = BaseHandler.responses[response](dataset)
return res(environ, start_response)
