def test_advanced_parenthesized_expression(self):
expression = "(1 + (2 + 3)) + ((2+3) + 1)"
parser = ExpressionParser()
tree = parser.parse(expression)
expected = "((1 + (2 + 3)) + ((2 + 3) + 1))"
assert str(tree) == expected, "The expression was not parsed correctly. Expecting %s, Found %s" % (expected, str(tree))
class Query(object):
def __init__(self, provider):
error_message = "The provider cannot be None. If you meant to use the CollectionProvider pass in a tuple or list"
Guard.against_none(provider, error_message)
if isinstance(provider, (list, tuple)):
self.provider = CollectionProvider(provider)
elif isinstance(provider, (dict,)):
self.provider = DictionaryProvider(provider)
else:
self.provider = provider
self.expressions = []
self.order_expressions = []
self.group_expression = None
self.parser = ExpressionParser()
def where(self, clause):
self.expressions.append(self.parser.parse(clause.strip()))
return self
def group_by(self, *args):
for arg in args:
self.group_expression = self.parser.parse(arg.strip())
return self
def order_by(self, *args):
for arg in args:
self.order_expressions.append(self.parser.parse(arg.strip()))
return self
def select(self, *cols):
empty_message = "Selecting with no fields is not valid. " \
+ "When using From(provider).select method, " \
+ "please provide a list of expressions or strings as fields."
Guard.against_empty(cols, empty_message)
for col in cols:
Guard.against_empty(col, empty_message)
Guard.accepts_only(cols, [str, Expression], "Selecting with invalid type. " \
+ "When using From(provider).select method, " \
+ "please provide a list of expressions or strings as fields.")
return self.provider.parse(self, action=Actions.Select, cols=cols)
def select_many(self):
return self.provider.parse(self, action=Actions.SelectMany)
def count(self):
return self.provider.parse(self, action=Actions.Count)
def max(self, column="item"):
return self.provider.parse(self, action=Actions.Max, column=column)
def min(self, column="item"):
return self.provider.parse(self, action=Actions.Min, column=column)
def sum(self, column="item"):
return self.provider.parse(self, action=Actions.Sum, column=column)
def avg(self, column="item"):
return self.provider.parse(self, action=Actions.Avg, column=column)
class Query(object):
def __init__(self, provider):
error_message = "The provider cannot be None. If you meant to use the CollectionProvider pass in a tuple or list"
Guard.against_none(provider, error_message)
if isinstance(provider, (list, tuple)):
self.provider = CollectionProvider(provider)
else:
self.provider = provider
self.expressions = []
self.order_expressions = []
self.group_expression = None
self.parser = ExpressionParser()
def where(self, clause):
self.expressions.append(self.parser.parse(clause.strip()))
return self
def group_by(self, *args):
for arg in args:
self.group_expression = self.parser.parse(arg.strip())
return self
def order_by(self, *args):
for arg in args:
self.order_expressions.append(self.parser.parse(arg.strip()))
return self
def select(self, *cols):
empty_message = "Selecting with no fields is not valid. " \
+ "When using From(provider).select method, " \
+ "please provide a list of expressions or strings as fields."
Guard.against_empty(cols, empty_message)
for col in cols:
Guard.against_empty(col, empty_message)
Guard.accepts_only(cols, [str, Expression], "Selecting with invalid type. " \
+ "When using From(provider).select method, " \
+ "please provide a list of expressions or strings as fields.")
return self.provider.parse(self, action=Actions.Select, cols=cols)
def select_many(self):
return self.provider.parse(self, action=Actions.SelectMany)
def count(self):
return self.provider.parse(self, action=Actions.Count)
def max(self, column="item"):
return self.provider.parse(self, action=Actions.Max, column=column)
def min(self, column="item"):
return self.provider.parse(self, action=Actions.Min, column=column)
def sum(self, column="item"):
return self.provider.parse(self, action=Actions.Sum, column=column)
def avg(self, column="item"):
return self.provider.parse(self, action=Actions.Avg, column=column)
def test_advanced_parenthesized_expression(self):
expression = "(1 + (2 + 3)) + ((2+3) + 1)"
parser = ExpressionParser()
tree = parser.parse(expression)
expected = "((1 + (2 + 3)) + ((2 + 3) + 1))"
assert str(tree) == expected, "The expression was not parsed correctly. Expecting %s, Found %s" % (
expected,
str(tree),
)
def __init__(self, provider):
error_message = "The provider cannot be None. If you meant to use the CollectionProvider pass in a tuple or list"
Guard.against_none(provider, error_message)
if isinstance(provider, (list, tuple)):
self.provider = CollectionProvider(provider)
else:
self.provider = provider
self.expressions = []
self.order_expressions = []
self.group_expression = None
self.parser = ExpressionParser()
def test_parser_raises_for_invalid_syntax(self):
parser = ExpressionParser()
self.assertRaisesEx(
SyntaxError,
parser.parse,
"1 + lambda: x",
exc_pattern=re.compile("unknown operator: '\(operator\)' ':'"))
def test_basic_parenthesized_expression_returns_constant_expressions_inside_rhs(self):
expression = "1 + (2 + 3)"
parser = ExpressionParser()
tree = parser.parse(expression)
assert isinstance(tree.rhs.lhs, ConstantExpression), "The lhs of the rhs should be a ConstantExpression"
assert isinstance(tree.rhs.rhs, ConstantExpression), "The rhs of the rhs should be a ConstantExpression"
def test_basic_parenthesized_expression_returns_not_null_expressions_inside_rhs(self):
expression = "1 + (2 + 3)"
parser = ExpressionParser()
tree = parser.parse(expression)
assert tree.rhs.lhs is not None, "The lhs of the rhs cannot be null"
assert tree.rhs.rhs is not None, "The rhs of the rhs cannot be null"
def test_basic_parenthesized_expression_returns_binary_expression_in_rhs(self):
expression = "1 + (2 + 3)"
parser = ExpressionParser()
tree = parser.parse(expression)
assert isinstance(tree.rhs, BinaryExpression), "The rhs should be a BinaryExpression"
def test_basic_parenthesized_expression_returns_proper_value_in_lhs(self):
expression = "1 + (2 + 3)"
parser = ExpressionParser()
tree = parser.parse(expression)
assert tree.lhs.value == "1", "The lhs should contain the '1' value"
def test_basic_parenthesized_expression_returns_constant_expression_in_lhs(self):
expression = "1 + (2 + 3)"
parser = ExpressionParser()
tree = parser.parse(expression)
assert tree.lhs is not None, "The lhs for the tree cannot be null"
assert isinstance(tree.lhs, ConstantExpression), "The lhs should be a constant expression"
def test_basic_parenthesized_expression_returns_not_null_expressions_inside_rhs(self):
expression = "1 + (2 + 3)"
parser = ExpressionParser()
tree = parser.parse(expression)
assert tree.rhs.lhs is not None, "The lhs of the rhs cannot be null"
assert tree.rhs.rhs is not None, "The rhs of the rhs cannot be null"
def test_basic_parenthesized_expression_returns_binary_expression(self):
expression = "1 + (2 + 3)"
parser = ExpressionParser()
tree = parser.parse(expression)
assert isinstance(tree, BinaryExpression), "The tree needs to be a binary expression"
# 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.
import unittest
import sys
from os.path import dirname, abspath, join
root_path = abspath(join(dirname(__file__), "../../"))
sys.path.insert(0, root_path)
from pynq.parser import ExpressionParser
from pynq.expressions import UnaryExpression, ConstantExpression
parser = ExpressionParser()
operations_to_test = {
UnaryExpression.Negate: (("-1", "1"), ),
UnaryExpression.Not: (("not 1", "1"), ),
}
def test_for_null_for_unary_expressions():
for operation in operations_to_test.keys():
for combination in operations_to_test[operation]:
program, rhs = combination
yield assert_not_null, program, operation, rhs
def test_for_type_of_expression_for_unary_expressions():
for operation in operations_to_test.keys():
def test_basic_parenthesized_expression_returns_something(self):
expression = "1 + (2 + 3)"
parser = ExpressionParser()
tree = parser.parse(expression)
assert tree is not None, "The tree cannot be null after parsing"
def test_basic_parenthesized_expression_returns_constant_expression_in_lhs(self):
expression = "1 + (2 + 3)"
parser = ExpressionParser()
tree = parser.parse(expression)
assert tree.lhs is not None, "The lhs for the tree cannot be null"
assert isinstance(tree.lhs, ConstantExpression), "The lhs should be a constant expression"
def test_basic_parenthesized_expression_returns_proper_value_in_lhs(self):
expression = "1 + (2 + 3)"
parser = ExpressionParser()
tree = parser.parse(expression)
assert tree.lhs.value == "1", "The lhs should contain the '1' value"
def test_advanced_parenthesized_expression(self):
expression = "(1 + 2 + 3) + ((2+3) + 1)"
parser = ExpressionParser()
tree = parser.parse(expression)
assert str(tree) == "(((1 + 2) + 3) + ((2 + 3) + 1))", "The expression was not parsed correctly"
def test_basic_parenthesized_expression_returns_proper_values_inside_rhs(self):
expression = "1 + (2 + 3)"
parser = ExpressionParser()
tree = parser.parse(expression)
assert tree.rhs.lhs.value == "2", "The lhs of the rhs should be 2 but was %s" % tree.rhs.lhs.value
assert tree.rhs.rhs.value == "3", "The rhs of the rhs should be 3 but was %s" % tree.rhs.rhs.value
def test_basic_parenthesized_expression_returns_constant_expressions_inside_rhs(self):
expression = "1 + (2 + 3)"
parser = ExpressionParser()
tree = parser.parse(expression)
assert isinstance(tree.rhs.lhs, ConstantExpression), "The lhs of the rhs should be a ConstantExpression"
assert isinstance(tree.rhs.rhs, ConstantExpression), "The rhs of the rhs should be a ConstantExpression"
def test_basic_parenthesized_expression_returns_proper_values_inside_rhs(self):
expression = "1 + (2 + 3)"
parser = ExpressionParser()
tree = parser.parse(expression)
assert tree.rhs.lhs.value == "2", "The lhs of the rhs should be 2 but was %s" % tree.rhs.lhs.value
assert tree.rhs.rhs.value == "3", "The rhs of the rhs should be 3 but was %s" % tree.rhs.rhs.value
def test_advanced_parenthesized_expression(self):
expression = "(1 + 2 + 3) + ((2+3) + 1)"
parser = ExpressionParser()
tree = parser.parse(expression)
assert str(tree) == "(((1 + 2) + 3) + ((2 + 3) + 1))", "The expression was not parsed correctly"
def test_basic_parenthesized_expression_returns_something(self):
expression = "1 + (2 + 3)"
parser = ExpressionParser()
tree = parser.parse(expression)
assert tree is not None, "The tree cannot be null after parsing"
def test_basic_parenthesized_expression_returns_binary_expression(self):
expression = "1 + (2 + 3)"
parser = ExpressionParser()
tree = parser.parse(expression)
assert isinstance(tree, BinaryExpression), "The tree needs to be a binary expression"
def test_basic_parenthesized_expression_returns_binary_expression_in_rhs(self):
expression = "1 + (2 + 3)"
parser = ExpressionParser()
tree = parser.parse(expression)
assert isinstance(tree.rhs, BinaryExpression), "The rhs should be a BinaryExpression"
