def test_unicode(self):
self.assertEqual(str_util.unicode(123), 123)
self.assertEqual(str_util.unicode("foobar"), "foobar")
self.assertEqual(
str_util.unicode(u"fubar" if six.PY2 else str("fubar")), "fubar")
self.assertEqual(str_util.unicode("鐵甲奇俠"), "鐵甲奇俠")
self.assertEqual(str_util.unicode("\xe9\x90\xb5\xe7\x94\xb2"),
"\xe9\x90\xb5\xe7\x94\xb2")
def test_unicode(self):
self.assertEqual(str_util.unicode(123), 123)
self.assertEqual(str_util.unicode('foobar'), 'foobar')
self.assertEqual(
str_util.unicode(unicode('fubar') if six.PY2 else str('fubar')),
'fubar')
self.assertEqual(str_util.unicode('鐵甲奇俠'), '鐵甲奇俠')
self.assertEqual(str_util.unicode('\xe9\x90\xb5\xe7\x94\xb2'),
'\xe9\x90\xb5\xe7\x94\xb2')
def _evaluate_and_expand(cls, text, data=None):
exprs = cls._regex_parser.findall(text)
block_exprs = cls._regex_block_parser.findall(text)
ctx = cls.contextualize(data)
opts = {"undefined_to_none": False}
try:
# If there is a Jinja block expression in the text, then process the whole text.
if block_exprs:
expr = text
output = cls._jinja_env.from_string(expr).render(ctx)
output = str_util.unicode(output)
# Traverse and evaulate again in case additional inline epxressions are
# introduced after the jinja block is evaluated.
output = cls._evaluate_and_expand(output, data)
else:
# The output will first be the original text and the expressions
# will be substituted by the evaluated value.
output = str_util.unicode(text)
# Evaluate inline jinja expressions first.
for expr in exprs:
stripped = cls.strip_delimiter(expr)
compiled = cls._jinja_env.compile_expression(
stripped, **opts)
result = compiled(**ctx)
if inspect.isgenerator(result):
result = list(result)
if isinstance(result, six.string_types):
result = cls._evaluate_and_expand(result, data)
# For StrictUndefined values, UndefinedError only gets raised when the value is
# accessed, not when it gets created. The simplest way to access it is to try
# and cast it to string. When StrictUndefined is cast to str below, this will
# raise an exception with error description.
if not isinstance(result, jinja2.runtime.StrictUndefined):
if len(exprs) > 1 or block_exprs or len(output) > len(
expr):
output = output.replace(
expr, str_util.unicode(result, force=True))
else:
output = str_util.unicode(result)
except jinja2.exceptions.UndefinedError as e:
msg = "Unable to evaluate expression '%s'. %s: %s"
raise JinjaEvaluationException(
msg % (expr, e.__class__.__name__, str(e)))
except Exception as e:
msg = "Unable to evaluate expression '%s'. %s: %s"
raise JinjaEvaluationException(
msg % (expr, e.__class__.__name__, str(e)))
return output
def assert_unicode_data_flow(self, input_value):
inputs = {
u"a1":
(str_util.unicode(input_value, encoding_type="utf-8", force=True)
if six.PY2 else input_value)
}
expected_output = {u"a5": inputs["a1"], u"b5": inputs["a1"]}
self._assert_data_flow(inputs, expected_output)
def evaluate(cls, text, data=None):
if not isinstance(text, six.string_types):
raise ValueError('Text to be evaluated is not typeof string.')
if data and not isinstance(data, dict):
raise ValueError('Provided data is not typeof dict.')
output = str_util.unicode(text)
exprs = cls._regex_parser.findall(text)
ctx = cls.contextualize(data)
try:
for expr in exprs:
stripped = cls.strip_delimiter(expr)
result = cls._engine(stripped).evaluate(context=ctx)
if inspect.isgenerator(result):
result = list(result)
if isinstance(result, six.string_types):
result = cls.evaluate(result, data)
if len(exprs) > 1 or len(output) > len(expr):
output = output.replace(
expr, str_util.unicode(result, force=True))
else:
output = str_util.unicode(result)
except KeyError as e:
error = str(getattr(e, 'message', e)).strip("'")
msg = "Unable to resolve key '%s' in expression '%s' from context."
raise YaqlEvaluationException(msg % (error, expr))
except (yaql_exc.YaqlException, ValueError, TypeError) as e:
msg = "Unable to evaluate expression '%s'. %s: %s"
raise YaqlEvaluationException(
msg % (expr, e.__class__.__name__, str(e).strip("'")))
except Exception as e:
msg = "Unable to evaluate expression '%s'. %s: %s"
raise YaqlEvaluationException(msg %
(expr, e.__class__.__name__, str(e)))
return output
def test_unicode_force(self):
self.assertEqual(strings.unicode(123, force=True), '123')
self.assertEqual(strings.unicode(123.45, force=True), '123.45')
self.assertEqual(strings.unicode(True, force=True), 'True')
self.assertEqual(strings.unicode(None, force=True), 'None')
self.assertEqual(strings.unicode([1, 2, 3], force=True), '[1, 2, 3]')
self.assertEqual(strings.unicode({'k': 'v'}, force=True), "{'k': 'v'}")
def test_unicode_force(self):
self.assertEqual(str_util.unicode(123, force=True), "123")
self.assertEqual(str_util.unicode(123.45, force=True), "123.45")
self.assertEqual(str_util.unicode(True, force=True), "True")
self.assertEqual(str_util.unicode(None, force=True), "None")
self.assertEqual(str_util.unicode([1, 2, 3], force=True), "[1, 2, 3]")
self.assertEqual(str_util.unicode({"k": "v"}, force=True),
"{'k': 'v'}")
def __unicode__(self):
return str_util.unicode(repr(self.spec))