| |
| |
| |
| |
| @@ -7,6 +7,9 @@ extend-exclude = [ |
| # Non UTF-8 files |
| "encoded_modules/module_iso_8859_1.py", |
| "encoded_modules/module_koi8_r.py", |
| + # SyntaxError because of t-strings |
| + "test_tstring.py", |
| + "test_string/test_templatelib.py", |
| # New grammar constructions may not yet be recognized by Ruff, |
| # and tests re-use the same names as only the grammar is being checked. |
| "test_grammar.py", |
| |
| |
| |
| |
| @@ -16,6 +16,9 @@ def traverse_compare(a, b, missing=object()): |
| self.fail(f"{type(a)!r} is not {type(b)!r}") |
| if isinstance(a, ast.AST): |
| for field in a._fields: |
| + if isinstance(a, ast.Constant) and field == "kind": |
| + # Skip the 'kind' field for ast.Constant |
| + continue |
| value1 = getattr(a, field, missing) |
| value2 = getattr(b, field, missing) |
| # Singletons are equal by definition, so further |
| |
| |
| |
| |
| @@ -206,4 +206,9 @@ Module(body=[Expr(value=IfExp(test=Name(...), body=Call(...), orelse=Call(...))) |
| Module(body=[Expr(value=JoinedStr(values=[FormattedValue(...)]))], type_ignores=[]) |
| Module(body=[Expr(value=JoinedStr(values=[FormattedValue(...)]))], type_ignores=[]) |
| Module(body=[Expr(value=JoinedStr(values=[FormattedValue(...)]))], type_ignores=[]) |
| -Module(body=[Expr(value=JoinedStr(values=[Constant(...), ..., Constant(...)]))], type_ignores=[]) |
| \ No newline at end of file |
| +Module(body=[Expr(value=JoinedStr(values=[Constant(...), ..., Constant(...)]))], type_ignores=[]) |
| +Module(body=[Expr(value=TemplateStr(values=[Interpolation(...)]))], type_ignores=[]) |
| +Module(body=[Expr(value=TemplateStr(values=[Interpolation(...)]))], type_ignores=[]) |
| +Module(body=[Expr(value=TemplateStr(values=[Interpolation(...)]))], type_ignores=[]) |
| +Module(body=[Expr(value=TemplateStr(values=[Interpolation(...)]))], type_ignores=[]) |
| +Module(body=[Expr(value=TemplateStr(values=[Constant(...), ..., Constant(...)]))], type_ignores=[]) |
| \ No newline at end of file |
| |
| |
| |
| |
| @@ -364,6 +364,12 @@ |
| "f'{a:.2f}'", |
| "f'{a!r}'", |
| "f'foo({a})'", |
| + # TemplateStr and Interpolation |
| + "t'{a}'", |
| + "t'{a:.2f}'", |
| + "t'{a!r}'", |
| + "t'{a!r:.2f}'", |
| + "t'foo({a})'", |
| ] |
| |
| |
| @@ -597,5 +603,10 @@ def main(): |
| ('Expression', ('JoinedStr', (1, 0, 1, 10), [('FormattedValue', (1, 2, 1, 9), ('Name', (1, 3, 1, 4), 'a', ('Load',)), -1, ('JoinedStr', (1, 4, 1, 8), [('Constant', (1, 5, 1, 8), '.2f', None)]))])), |
| ('Expression', ('JoinedStr', (1, 0, 1, 8), [('FormattedValue', (1, 2, 1, 7), ('Name', (1, 3, 1, 4), 'a', ('Load',)), 114, None)])), |
| ('Expression', ('JoinedStr', (1, 0, 1, 11), [('Constant', (1, 2, 1, 6), 'foo(', None), ('FormattedValue', (1, 6, 1, 9), ('Name', (1, 7, 1, 8), 'a', ('Load',)), -1, None), ('Constant', (1, 9, 1, 10), ')', None)])), |
| +('Expression', ('TemplateStr', (1, 0, 1, 6), [('Interpolation', (1, 2, 1, 5), ('Name', (1, 3, 1, 4), 'a', ('Load',)), 'a', -1, None)])), |
| +('Expression', ('TemplateStr', (1, 0, 1, 10), [('Interpolation', (1, 2, 1, 9), ('Name', (1, 3, 1, 4), 'a', ('Load',)), 'a', -1, ('JoinedStr', (1, 4, 1, 8), [('Constant', (1, 5, 1, 8), '.2f', None)]))])), |
| +('Expression', ('TemplateStr', (1, 0, 1, 8), [('Interpolation', (1, 2, 1, 7), ('Name', (1, 3, 1, 4), 'a', ('Load',)), 'a', 114, None)])), |
| +('Expression', ('TemplateStr', (1, 0, 1, 12), [('Interpolation', (1, 2, 1, 11), ('Name', (1, 3, 1, 4), 'a', ('Load',)), 'a', 114, ('JoinedStr', (1, 6, 1, 10), [('Constant', (1, 7, 1, 10), '.2f', None)]))])), |
| +('Expression', ('TemplateStr', (1, 0, 1, 11), [('Constant', (1, 2, 1, 6), 'foo(', None), ('Interpolation', (1, 6, 1, 9), ('Name', (1, 7, 1, 8), 'a', ('Load',)), 'a', -1, None), ('Constant', (1, 9, 1, 10), ')', None)])), |
| ] |
| main() |
| |
| |
| |
| |
| @@ -880,6 +880,25 @@ def f(): |
| for src in srcs: |
| ast.parse(src) |
| |
| + def test_tstring(self): |
| + # Test AST structure for simple t-string |
| + tree = ast.parse('t"Hello"') |
| + self.assertIsInstance(tree.body[0].value, ast.TemplateStr) |
| + self.assertIsInstance(tree.body[0].value.values[0], ast.Constant) |
| + |
| + # Test AST for t-string with interpolation |
| + tree = ast.parse('t"Hello {name}"') |
| + self.assertIsInstance(tree.body[0].value, ast.TemplateStr) |
| + self.assertIsInstance(tree.body[0].value.values[0], ast.Constant) |
| + self.assertIsInstance(tree.body[0].value.values[1], ast.Interpolation) |
| + |
| + # Test AST for implicit concat of t-string with f-string |
| + tree = ast.parse('t"Hello {name}" f"{name}"') |
| + self.assertIsInstance(tree.body[0].value, ast.TemplateStr) |
| + self.assertIsInstance(tree.body[0].value.values[0], ast.Constant) |
| + self.assertIsInstance(tree.body[0].value.values[1], ast.Interpolation) |
| + self.assertIsInstance(tree.body[0].value.values[2], ast.FormattedValue) |
| + |
| |
| class CopyTests(unittest.TestCase): |
| """Test copying and pickling AST nodes.""" |
| |
| |
| |
| |
| @@ -1358,7 +1358,6 @@ def test_conversions(self): |
| self.assertAllRaise(SyntaxError, "f-string: expecting '}'", |
| ["f'{3!'", |
| "f'{3!s'", |
| - "f'{3!g'", |
| ]) |
| |
| self.assertAllRaise(SyntaxError, 'f-string: missing conversion character', |
| |
| |
| |
| |
| @@ -1507,6 +1507,8 @@ def check(test): |
| check('[None (3, 4)]') |
| check('[True (3, 4)]') |
| check('[... (3, 4)]') |
| + check('[t"{x}" (3, 4)]') |
| + check('[t"x={x}" (3, 4)]') |
| |
| msg=r'is not subscriptable; perhaps you missed a comma\?' |
| check('[{1, 2} [i, j]]') |
| @@ -1529,6 +1531,8 @@ def check(test): |
| check('[f"x={x}" [i, j]]') |
| check('["abc" [i, j]]') |
| check('[b"abc" [i, j]]') |
| + check('[t"{x}" [i, j]]') |
| + check('[t"x={x}" [i, j]]') |
| |
| msg=r'indices must be integers or slices, not tuple;' |
| check('[[1, 2] [3, 4]]') |
| @@ -1549,6 +1553,8 @@ def check(test): |
| check('[[1, 2] [f"{x}"]]') |
| check('[[1, 2] [f"x={x}"]]') |
| check('[[1, 2] ["abc"]]') |
| + check('[[1, 2] [t"{x}"]]') |
| + check('[[1, 2] [t"x={x}"]]') |
| msg=r'indices must be integers or slices, not' |
| check('[[1, 2] [b"abc"]]') |
| check('[[1, 2] [12.3]]') |
| |
| deleted file mode 100644 |
| |
| |
| |
| @@ -1,550 +0,0 @@ |
| -import unittest |
| -import string |
| -from string import Template |
| -import types |
| - |
| - |
| -class ModuleTest(unittest.TestCase): |
| - |
| - def test_attrs(self): |
| - # While the exact order of the items in these attributes is not |
| - # technically part of the "language spec", in practice there is almost |
| - # certainly user code that depends on the order, so de-facto it *is* |
| - # part of the spec. |
| - self.assertEqual(string.whitespace, ' \t\n\r\x0b\x0c') |
| - self.assertEqual(string.ascii_lowercase, 'abcdefghijklmnopqrstuvwxyz') |
| - self.assertEqual(string.ascii_uppercase, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ') |
| - self.assertEqual(string.ascii_letters, string.ascii_lowercase + string.ascii_uppercase) |
| - self.assertEqual(string.digits, '0123456789') |
| - self.assertEqual(string.hexdigits, string.digits + 'abcdefABCDEF') |
| - self.assertEqual(string.octdigits, '01234567') |
| - self.assertEqual(string.punctuation, '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~') |
| - self.assertEqual(string.printable, string.digits + string.ascii_lowercase + string.ascii_uppercase + string.punctuation + string.whitespace) |
| - |
| - def test_capwords(self): |
| - self.assertEqual(string.capwords('abc def ghi'), 'Abc Def Ghi') |
| - self.assertEqual(string.capwords('abc\tdef\nghi'), 'Abc Def Ghi') |
| - self.assertEqual(string.capwords('abc\t def \nghi'), 'Abc Def Ghi') |
| - self.assertEqual(string.capwords('ABC DEF GHI'), 'Abc Def Ghi') |
| - self.assertEqual(string.capwords('ABC-DEF-GHI', '-'), 'Abc-Def-Ghi') |
| - self.assertEqual(string.capwords('ABC-def DEF-ghi GHI'), 'Abc-def Def-ghi Ghi') |
| - self.assertEqual(string.capwords(' aBc DeF '), 'Abc Def') |
| - self.assertEqual(string.capwords('\taBc\tDeF\t'), 'Abc Def') |
| - self.assertEqual(string.capwords('\taBc\tDeF\t', '\t'), '\tAbc\tDef\t') |
| - |
| - def test_basic_formatter(self): |
| - fmt = string.Formatter() |
| - self.assertEqual(fmt.format("foo"), "foo") |
| - self.assertEqual(fmt.format("foo{0}", "bar"), "foobar") |
| - self.assertEqual(fmt.format("foo{1}{0}-{1}", "bar", 6), "foo6bar-6") |
| - self.assertRaises(TypeError, fmt.format) |
| - self.assertRaises(TypeError, string.Formatter.format) |
| - |
| - def test_format_keyword_arguments(self): |
| - fmt = string.Formatter() |
| - self.assertEqual(fmt.format("-{arg}-", arg='test'), '-test-') |
| - self.assertRaises(KeyError, fmt.format, "-{arg}-") |
| - self.assertEqual(fmt.format("-{self}-", self='test'), '-test-') |
| - self.assertRaises(KeyError, fmt.format, "-{self}-") |
| - self.assertEqual(fmt.format("-{format_string}-", format_string='test'), |
| - '-test-') |
| - self.assertRaises(KeyError, fmt.format, "-{format_string}-") |
| - with self.assertRaisesRegex(TypeError, "format_string"): |
| - fmt.format(format_string="-{arg}-", arg='test') |
| - |
| - def test_auto_numbering(self): |
| - fmt = string.Formatter() |
| - self.assertEqual(fmt.format('foo{}{}', 'bar', 6), |
| - 'foo{}{}'.format('bar', 6)) |
| - self.assertEqual(fmt.format('foo{1}{num}{1}', None, 'bar', num=6), |
| - 'foo{1}{num}{1}'.format(None, 'bar', num=6)) |
| - self.assertEqual(fmt.format('{:^{}}', 'bar', 6), |
| - '{:^{}}'.format('bar', 6)) |
| - self.assertEqual(fmt.format('{:^{}} {}', 'bar', 6, 'X'), |
| - '{:^{}} {}'.format('bar', 6, 'X')) |
| - self.assertEqual(fmt.format('{:^{pad}}{}', 'foo', 'bar', pad=6), |
| - '{:^{pad}}{}'.format('foo', 'bar', pad=6)) |
| - |
| - with self.assertRaises(ValueError): |
| - fmt.format('foo{1}{}', 'bar', 6) |
| - |
| - with self.assertRaises(ValueError): |
| - fmt.format('foo{}{1}', 'bar', 6) |
| - |
| - def test_conversion_specifiers(self): |
| - fmt = string.Formatter() |
| - self.assertEqual(fmt.format("-{arg!r}-", arg='test'), "-'test'-") |
| - self.assertEqual(fmt.format("{0!s}", 'test'), 'test') |
| - self.assertRaises(ValueError, fmt.format, "{0!h}", 'test') |
| - # issue13579 |
| - self.assertEqual(fmt.format("{0!a}", 42), '42') |
| - self.assertEqual(fmt.format("{0!a}", string.ascii_letters), |
| - "'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'") |
| - self.assertEqual(fmt.format("{0!a}", chr(255)), "'\\xff'") |
| - self.assertEqual(fmt.format("{0!a}", chr(256)), "'\\u0100'") |
| - |
| - def test_name_lookup(self): |
| - fmt = string.Formatter() |
| - class AnyAttr: |
| - def __getattr__(self, attr): |
| - return attr |
| - x = AnyAttr() |
| - self.assertEqual(fmt.format("{0.lumber}{0.jack}", x), 'lumberjack') |
| - with self.assertRaises(AttributeError): |
| - fmt.format("{0.lumber}{0.jack}", '') |
| - |
| - def test_index_lookup(self): |
| - fmt = string.Formatter() |
| - lookup = ["eggs", "and", "spam"] |
| - self.assertEqual(fmt.format("{0[2]}{0[0]}", lookup), 'spameggs') |
| - with self.assertRaises(IndexError): |
| - fmt.format("{0[2]}{0[0]}", []) |
| - with self.assertRaises(KeyError): |
| - fmt.format("{0[2]}{0[0]}", {}) |
| - |
| - def test_auto_numbering_lookup(self): |
| - fmt = string.Formatter() |
| - namespace = types.SimpleNamespace(foo=types.SimpleNamespace(bar='baz')) |
| - widths = [None, types.SimpleNamespace(qux=4)] |
| - self.assertEqual( |
| - fmt.format("{.foo.bar:{[1].qux}}", namespace, widths), 'baz ') |
| - |
| - def test_auto_numbering_reenterability(self): |
| - class ReenteringFormatter(string.Formatter): |
| - def format_field(self, value, format_spec): |
| - if format_spec.isdigit() and int(format_spec) > 0: |
| - return self.format('{:{}}!', value, int(format_spec) - 1) |
| - else: |
| - return super().format_field(value, format_spec) |
| - fmt = ReenteringFormatter() |
| - x = types.SimpleNamespace(a='X') |
| - self.assertEqual(fmt.format('{.a:{}}', x, 3), 'X!!!') |
| - |
| - def test_override_get_value(self): |
| - class NamespaceFormatter(string.Formatter): |
| - def __init__(self, namespace={}): |
| - string.Formatter.__init__(self) |
| - self.namespace = namespace |
| - |
| - def get_value(self, key, args, kwds): |
| - if isinstance(key, str): |
| - try: |
| - # Check explicitly passed arguments first |
| - return kwds[key] |
| - except KeyError: |
| - return self.namespace[key] |
| - else: |
| - string.Formatter.get_value(key, args, kwds) |
| - |
| - fmt = NamespaceFormatter({'greeting':'hello'}) |
| - self.assertEqual(fmt.format("{greeting}, world!"), 'hello, world!') |
| - |
| - |
| - def test_override_format_field(self): |
| - class CallFormatter(string.Formatter): |
| - def format_field(self, value, format_spec): |
| - return format(value(), format_spec) |
| - |
| - fmt = CallFormatter() |
| - self.assertEqual(fmt.format('*{0}*', lambda : 'result'), '*result*') |
| - |
| - |
| - def test_override_convert_field(self): |
| - class XFormatter(string.Formatter): |
| - def convert_field(self, value, conversion): |
| - if conversion == 'x': |
| - return None |
| - return super().convert_field(value, conversion) |
| - |
| - fmt = XFormatter() |
| - self.assertEqual(fmt.format("{0!r}:{0!x}", 'foo', 'foo'), "'foo':None") |
| - |
| - |
| - def test_override_parse(self): |
| - class BarFormatter(string.Formatter): |
| - # returns an iterable that contains tuples of the form: |
| - # (literal_text, field_name, format_spec, conversion) |
| - def parse(self, format_string): |
| - for field in format_string.split('|'): |
| - if field[0] == '+': |
| - # it's markup |
| - field_name, _, format_spec = field[1:].partition(':') |
| - yield '', field_name, format_spec, None |
| - else: |
| - yield field, None, None, None |
| - |
| - fmt = BarFormatter() |
| - self.assertEqual(fmt.format('*|+0:^10s|*', 'foo'), '* foo *') |
| - |
| - def test_check_unused_args(self): |
| - class CheckAllUsedFormatter(string.Formatter): |
| - def check_unused_args(self, used_args, args, kwargs): |
| - # Track which arguments actually got used |
| - unused_args = set(kwargs.keys()) |
| - unused_args.update(range(0, len(args))) |
| - |
| - for arg in used_args: |
| - unused_args.remove(arg) |
| - |
| - if unused_args: |
| - raise ValueError("unused arguments") |
| - |
| - fmt = CheckAllUsedFormatter() |
| - self.assertEqual(fmt.format("{0}", 10), "10") |
| - self.assertEqual(fmt.format("{0}{i}", 10, i=100), "10100") |
| - self.assertEqual(fmt.format("{0}{i}{1}", 10, 20, i=100), "1010020") |
| - self.assertRaises(ValueError, fmt.format, "{0}{i}{1}", 10, 20, i=100, j=0) |
| - self.assertRaises(ValueError, fmt.format, "{0}", 10, 20) |
| - self.assertRaises(ValueError, fmt.format, "{0}", 10, 20, i=100) |
| - self.assertRaises(ValueError, fmt.format, "{i}", 10, 20, i=100) |
| - |
| - def test_vformat_recursion_limit(self): |
| - fmt = string.Formatter() |
| - args = () |
| - kwargs = dict(i=100) |
| - with self.assertRaises(ValueError) as err: |
| - fmt._vformat("{i}", args, kwargs, set(), -1) |
| - self.assertIn("recursion", str(err.exception)) |
| - |
| - |
| -# Template tests (formerly housed in test_pep292.py) |
| - |
| -class Bag: |
| - pass |
| - |
| -class Mapping: |
| - def __getitem__(self, name): |
| - obj = self |
| - for part in name.split('.'): |
| - try: |
| - obj = getattr(obj, part) |
| - except AttributeError: |
| - raise KeyError(name) |
| - return obj |
| - |
| - |
| -class TestTemplate(unittest.TestCase): |
| - def test_regular_templates(self): |
| - s = Template('$who likes to eat a bag of $what worth $$100') |
| - self.assertEqual(s.substitute(dict(who='tim', what='ham')), |
| - 'tim likes to eat a bag of ham worth $100') |
| - self.assertRaises(KeyError, s.substitute, dict(who='tim')) |
| - self.assertRaises(TypeError, Template.substitute) |
| - |
| - def test_regular_templates_with_braces(self): |
| - s = Template('$who likes ${what} for ${meal}') |
| - d = dict(who='tim', what='ham', meal='dinner') |
| - self.assertEqual(s.substitute(d), 'tim likes ham for dinner') |
| - self.assertRaises(KeyError, s.substitute, |
| - dict(who='tim', what='ham')) |
| - |
| - def test_regular_templates_with_upper_case(self): |
| - s = Template('$WHO likes ${WHAT} for ${MEAL}') |
| - d = dict(WHO='tim', WHAT='ham', MEAL='dinner') |
| - self.assertEqual(s.substitute(d), 'tim likes ham for dinner') |
| - |
| - def test_regular_templates_with_non_letters(self): |
| - s = Template('$_wh0_ likes ${_w_h_a_t_} for ${mea1}') |
| - d = dict(_wh0_='tim', _w_h_a_t_='ham', mea1='dinner') |
| - self.assertEqual(s.substitute(d), 'tim likes ham for dinner') |
| - |
| - def test_escapes(self): |
| - eq = self.assertEqual |
| - s = Template('$who likes to eat a bag of $$what worth $$100') |
| - eq(s.substitute(dict(who='tim', what='ham')), |
| - 'tim likes to eat a bag of $what worth $100') |
| - s = Template('$who likes $$') |
| - eq(s.substitute(dict(who='tim', what='ham')), 'tim likes $') |
| - |
| - def test_percents(self): |
| - eq = self.assertEqual |
| - s = Template('%(foo)s $foo ${foo}') |
| - d = dict(foo='baz') |
| - eq(s.substitute(d), '%(foo)s baz baz') |
| - eq(s.safe_substitute(d), '%(foo)s baz baz') |
| - |
| - def test_stringification(self): |
| - eq = self.assertEqual |
| - s = Template('tim has eaten $count bags of ham today') |
| - d = dict(count=7) |
| - eq(s.substitute(d), 'tim has eaten 7 bags of ham today') |
| - eq(s.safe_substitute(d), 'tim has eaten 7 bags of ham today') |
| - s = Template('tim has eaten ${count} bags of ham today') |
| - eq(s.substitute(d), 'tim has eaten 7 bags of ham today') |
| - |
| - def test_tupleargs(self): |
| - eq = self.assertEqual |
| - s = Template('$who ate ${meal}') |
| - d = dict(who=('tim', 'fred'), meal=('ham', 'kung pao')) |
| - eq(s.substitute(d), "('tim', 'fred') ate ('ham', 'kung pao')") |
| - eq(s.safe_substitute(d), "('tim', 'fred') ate ('ham', 'kung pao')") |
| - |
| - def test_SafeTemplate(self): |
| - eq = self.assertEqual |
| - s = Template('$who likes ${what} for ${meal}') |
| - eq(s.safe_substitute(dict(who='tim')), 'tim likes ${what} for ${meal}') |
| - eq(s.safe_substitute(dict(what='ham')), '$who likes ham for ${meal}') |
| - eq(s.safe_substitute(dict(what='ham', meal='dinner')), |
| - '$who likes ham for dinner') |
| - eq(s.safe_substitute(dict(who='tim', what='ham')), |
| - 'tim likes ham for ${meal}') |
| - eq(s.safe_substitute(dict(who='tim', what='ham', meal='dinner')), |
| - 'tim likes ham for dinner') |
| - |
| - def test_invalid_placeholders(self): |
| - raises = self.assertRaises |
| - s = Template('$who likes $') |
| - raises(ValueError, s.substitute, dict(who='tim')) |
| - s = Template('$who likes ${what)') |
| - raises(ValueError, s.substitute, dict(who='tim')) |
| - s = Template('$who likes $100') |
| - raises(ValueError, s.substitute, dict(who='tim')) |
| - # Template.idpattern should match to only ASCII characters. |
| - # https://bugs.python.org/issue31672 |
| - s = Template("$who likes $\u0131") # (DOTLESS I) |
| - raises(ValueError, s.substitute, dict(who='tim')) |
| - s = Template("$who likes $\u0130") # (LATIN CAPITAL LETTER I WITH DOT ABOVE) |
| - raises(ValueError, s.substitute, dict(who='tim')) |
| - |
| - def test_idpattern_override(self): |
| - class PathPattern(Template): |
| - idpattern = r'[_a-z][._a-z0-9]*' |
| - m = Mapping() |
| - m.bag = Bag() |
| - m.bag.foo = Bag() |
| - m.bag.foo.who = 'tim' |
| - m.bag.what = 'ham' |
| - s = PathPattern('$bag.foo.who likes to eat a bag of $bag.what') |
| - self.assertEqual(s.substitute(m), 'tim likes to eat a bag of ham') |
| - |
| - def test_flags_override(self): |
| - class MyPattern(Template): |
| - flags = 0 |
| - s = MyPattern('$wHO likes ${WHAT} for ${meal}') |
| - d = dict(wHO='tim', WHAT='ham', meal='dinner', w='fred') |
| - self.assertRaises(ValueError, s.substitute, d) |
| - self.assertEqual(s.safe_substitute(d), 'fredHO likes ${WHAT} for dinner') |
| - |
| - def test_idpattern_override_inside_outside(self): |
| - # bpo-1198569: Allow the regexp inside and outside braces to be |
| - # different when deriving from Template. |
| - class MyPattern(Template): |
| - idpattern = r'[a-z]+' |
| - braceidpattern = r'[A-Z]+' |
| - flags = 0 |
| - m = dict(foo='foo', BAR='BAR') |
| - s = MyPattern('$foo ${BAR}') |
| - self.assertEqual(s.substitute(m), 'foo BAR') |
| - |
| - def test_idpattern_override_inside_outside_invalid_unbraced(self): |
| - # bpo-1198569: Allow the regexp inside and outside braces to be |
| - # different when deriving from Template. |
| - class MyPattern(Template): |
| - idpattern = r'[a-z]+' |
| - braceidpattern = r'[A-Z]+' |
| - flags = 0 |
| - m = dict(foo='foo', BAR='BAR') |
| - s = MyPattern('$FOO') |
| - self.assertRaises(ValueError, s.substitute, m) |
| - s = MyPattern('${bar}') |
| - self.assertRaises(ValueError, s.substitute, m) |
| - |
| - def test_pattern_override(self): |
| - class MyPattern(Template): |
| - pattern = r""" |
| - (?P<escaped>@{2}) | |
| - @(?P<named>[_a-z][._a-z0-9]*) | |
| - @{(?P<braced>[_a-z][._a-z0-9]*)} | |
| - (?P<invalid>@) |
| - """ |
| - m = Mapping() |
| - m.bag = Bag() |
| - m.bag.foo = Bag() |
| - m.bag.foo.who = 'tim' |
| - m.bag.what = 'ham' |
| - s = MyPattern('@bag.foo.who likes to eat a bag of @bag.what') |
| - self.assertEqual(s.substitute(m), 'tim likes to eat a bag of ham') |
| - |
| - class BadPattern(Template): |
| - pattern = r""" |
| - (?P<badname>.*) | |
| - (?P<escaped>@{2}) | |
| - @(?P<named>[_a-z][._a-z0-9]*) | |
| - @{(?P<braced>[_a-z][._a-z0-9]*)} | |
| - (?P<invalid>@) | |
| - """ |
| - s = BadPattern('@bag.foo.who likes to eat a bag of @bag.what') |
| - self.assertRaises(ValueError, s.substitute, {}) |
| - self.assertRaises(ValueError, s.safe_substitute, {}) |
| - |
| - def test_braced_override(self): |
| - class MyTemplate(Template): |
| - pattern = r""" |
| - \$(?: |
| - (?P<escaped>$) | |
| - (?P<named>[_a-z][_a-z0-9]*) | |
| - @@(?P<braced>[_a-z][_a-z0-9]*)@@ | |
| - (?P<invalid>) | |
| - ) |
| - """ |
| - |
| - tmpl = 'PyCon in $@@location@@' |
| - t = MyTemplate(tmpl) |
| - self.assertRaises(KeyError, t.substitute, {}) |
| - val = t.substitute({'location': 'Cleveland'}) |
| - self.assertEqual(val, 'PyCon in Cleveland') |
| - |
| - def test_braced_override_safe(self): |
| - class MyTemplate(Template): |
| - pattern = r""" |
| - \$(?: |
| - (?P<escaped>$) | |
| - (?P<named>[_a-z][_a-z0-9]*) | |
| - @@(?P<braced>[_a-z][_a-z0-9]*)@@ | |
| - (?P<invalid>) | |
| - ) |
| - """ |
| - |
| - tmpl = 'PyCon in $@@location@@' |
| - t = MyTemplate(tmpl) |
| - self.assertEqual(t.safe_substitute(), tmpl) |
| - val = t.safe_substitute({'location': 'Cleveland'}) |
| - self.assertEqual(val, 'PyCon in Cleveland') |
| - |
| - def test_invalid_with_no_lines(self): |
| - # The error formatting for invalid templates |
| - # has a special case for no data that the default |
| - # pattern can't trigger (always has at least '$') |
| - # So we craft a pattern that is always invalid |
| - # with no leading data. |
| - class MyTemplate(Template): |
| - pattern = r""" |
| - (?P<invalid>) | |
| - unreachable( |
| - (?P<named>) | |
| - (?P<braced>) | |
| - (?P<escaped>) |
| - ) |
| - """ |
| - s = MyTemplate('') |
| - with self.assertRaises(ValueError) as err: |
| - s.substitute({}) |
| - self.assertIn('line 1, col 1', str(err.exception)) |
| - |
| - def test_unicode_values(self): |
| - s = Template('$who likes $what') |
| - d = dict(who='t\xffm', what='f\xfe\fed') |
| - self.assertEqual(s.substitute(d), 't\xffm likes f\xfe\x0ced') |
| - |
| - def test_keyword_arguments(self): |
| - eq = self.assertEqual |
| - s = Template('$who likes $what') |
| - eq(s.substitute(who='tim', what='ham'), 'tim likes ham') |
| - eq(s.substitute(dict(who='tim'), what='ham'), 'tim likes ham') |
| - eq(s.substitute(dict(who='fred', what='kung pao'), |
| - who='tim', what='ham'), |
| - 'tim likes ham') |
| - s = Template('the mapping is $mapping') |
| - eq(s.substitute(dict(foo='none'), mapping='bozo'), |
| - 'the mapping is bozo') |
| - eq(s.substitute(dict(mapping='one'), mapping='two'), |
| - 'the mapping is two') |
| - |
| - s = Template('the self is $self') |
| - eq(s.substitute(self='bozo'), 'the self is bozo') |
| - |
| - def test_keyword_arguments_safe(self): |
| - eq = self.assertEqual |
| - raises = self.assertRaises |
| - s = Template('$who likes $what') |
| - eq(s.safe_substitute(who='tim', what='ham'), 'tim likes ham') |
| - eq(s.safe_substitute(dict(who='tim'), what='ham'), 'tim likes ham') |
| - eq(s.safe_substitute(dict(who='fred', what='kung pao'), |
| - who='tim', what='ham'), |
| - 'tim likes ham') |
| - s = Template('the mapping is $mapping') |
| - eq(s.safe_substitute(dict(foo='none'), mapping='bozo'), |
| - 'the mapping is bozo') |
| - eq(s.safe_substitute(dict(mapping='one'), mapping='two'), |
| - 'the mapping is two') |
| - d = dict(mapping='one') |
| - raises(TypeError, s.substitute, d, {}) |
| - raises(TypeError, s.safe_substitute, d, {}) |
| - |
| - s = Template('the self is $self') |
| - eq(s.safe_substitute(self='bozo'), 'the self is bozo') |
| - |
| - def test_delimiter_override(self): |
| - eq = self.assertEqual |
| - raises = self.assertRaises |
| - class AmpersandTemplate(Template): |
| - delimiter = '&' |
| - s = AmpersandTemplate('this &gift is for &{who} &&') |
| - eq(s.substitute(gift='bud', who='you'), 'this bud is for you &') |
| - raises(KeyError, s.substitute) |
| - eq(s.safe_substitute(gift='bud', who='you'), 'this bud is for you &') |
| - eq(s.safe_substitute(), 'this &gift is for &{who} &') |
| - s = AmpersandTemplate('this &gift is for &{who} &') |
| - raises(ValueError, s.substitute, dict(gift='bud', who='you')) |
| - eq(s.safe_substitute(), 'this &gift is for &{who} &') |
| - |
| - class PieDelims(Template): |
| - delimiter = '@' |
| - s = PieDelims('@who likes to eat a bag of @{what} worth $100') |
| - self.assertEqual(s.substitute(dict(who='tim', what='ham')), |
| - 'tim likes to eat a bag of ham worth $100') |
| - |
| - def test_is_valid(self): |
| - eq = self.assertEqual |
| - s = Template('$who likes to eat a bag of ${what} worth $$100') |
| - self.assertTrue(s.is_valid()) |
| - |
| - s = Template('$who likes to eat a bag of ${what} worth $100') |
| - self.assertFalse(s.is_valid()) |
| - |
| - # if the pattern has an unrecognized capture group, |
| - # it should raise ValueError like substitute and safe_substitute do |
| - class BadPattern(Template): |
| - pattern = r""" |
| - (?P<badname>.*) | |
| - (?P<escaped>@{2}) | |
| - @(?P<named>[_a-z][._a-z0-9]*) | |
| - @{(?P<braced>[_a-z][._a-z0-9]*)} | |
| - (?P<invalid>@) | |
| - """ |
| - s = BadPattern('@bag.foo.who likes to eat a bag of @bag.what') |
| - self.assertRaises(ValueError, s.is_valid) |
| - |
| - def test_get_identifiers(self): |
| - eq = self.assertEqual |
| - raises = self.assertRaises |
| - s = Template('$who likes to eat a bag of ${what} worth $$100') |
| - ids = s.get_identifiers() |
| - eq(ids, ['who', 'what']) |
| - |
| - # repeated identifiers only included once |
| - s = Template('$who likes to eat a bag of ${what} worth $$100; ${who} likes to eat a bag of $what worth $$100') |
| - ids = s.get_identifiers() |
| - eq(ids, ['who', 'what']) |
| - |
| - # invalid identifiers are ignored |
| - s = Template('$who likes to eat a bag of ${what} worth $100') |
| - ids = s.get_identifiers() |
| - eq(ids, ['who', 'what']) |
| - |
| - # if the pattern has an unrecognized capture group, |
| - # it should raise ValueError like substitute and safe_substitute do |
| - class BadPattern(Template): |
| - pattern = r""" |
| - (?P<badname>.*) | |
| - (?P<escaped>@{2}) | |
| - @(?P<named>[_a-z][._a-z0-9]*) | |
| - @{(?P<braced>[_a-z][._a-z0-9]*)} | |
| - (?P<invalid>@) | |
| - """ |
| - s = BadPattern('@bag.foo.who likes to eat a bag of @bag.what') |
| - self.assertRaises(ValueError, s.get_identifiers) |
| - |
| - |
| -if __name__ == '__main__': |
| - unittest.main() |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,5 @@ |
| +import os |
| +from test.support import load_package_tests |
| + |
| +def load_tests(*args): |
| + return load_package_tests(os.path.dirname(__file__), *args) |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,55 @@ |
| +import unittest |
| +from string.templatelib import Interpolation |
| + |
| + |
| +class TStringBaseCase: |
| + def assertTStringEqual(self, t, strings, interpolations): |
| + """Test template string literal equality. |
| + |
| + The *strings* argument must be a tuple of strings equal to *t.strings*. |
| + |
| + The *interpolations* argument must be a sequence of tuples which are |
| + compared against *t.interpolations*. Each tuple consists of |
| + (value, expression, conversion, format_spec), though the final two |
| + items may be omitted, and are assumed to be None and '' respectively. |
| + """ |
| + self.assertEqual(t.strings, strings) |
| + self.assertEqual(len(t.interpolations), len(interpolations)) |
| + |
| + for i, exp in zip(t.interpolations, interpolations, strict=True): |
| + if len(exp) == 4: |
| + actual = (i.value, i.expression, i.conversion, i.format_spec) |
| + self.assertEqual(actual, exp) |
| + continue |
| + |
| + if len(exp) == 3: |
| + self.assertEqual((i.value, i.expression, i.conversion), exp) |
| + self.assertEqual(i.format_spec, '') |
| + continue |
| + |
| + self.assertEqual((i.value, i.expression), exp) |
| + self.assertEqual(i.format_spec, '') |
| + self.assertIsNone(i.conversion) |
| + |
| + |
| +def convert(value, conversion): |
| + if conversion == "a": |
| + return ascii(value) |
| + elif conversion == "r": |
| + return repr(value) |
| + elif conversion == "s": |
| + return str(value) |
| + return value |
| + |
| + |
| +def fstring(template): |
| + parts = [] |
| + for item in template: |
| + match item: |
| + case str() as s: |
| + parts.append(s) |
| + case Interpolation(value, _, conversion, format_spec): |
| + value = convert(value, conversion) |
| + value = format(value, format_spec) |
| + parts.append(value) |
| + return "".join(parts) |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,550 @@ |
| +import unittest |
| +import string |
| +from string import Template |
| +import types |
| + |
| + |
| +class ModuleTest(unittest.TestCase): |
| + |
| + def test_attrs(self): |
| + # While the exact order of the items in these attributes is not |
| + # technically part of the "language spec", in practice there is almost |
| + # certainly user code that depends on the order, so de-facto it *is* |
| + # part of the spec. |
| + self.assertEqual(string.whitespace, ' \t\n\r\x0b\x0c') |
| + self.assertEqual(string.ascii_lowercase, 'abcdefghijklmnopqrstuvwxyz') |
| + self.assertEqual(string.ascii_uppercase, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ') |
| + self.assertEqual(string.ascii_letters, string.ascii_lowercase + string.ascii_uppercase) |
| + self.assertEqual(string.digits, '0123456789') |
| + self.assertEqual(string.hexdigits, string.digits + 'abcdefABCDEF') |
| + self.assertEqual(string.octdigits, '01234567') |
| + self.assertEqual(string.punctuation, '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~') |
| + self.assertEqual(string.printable, string.digits + string.ascii_lowercase + string.ascii_uppercase + string.punctuation + string.whitespace) |
| + |
| + def test_capwords(self): |
| + self.assertEqual(string.capwords('abc def ghi'), 'Abc Def Ghi') |
| + self.assertEqual(string.capwords('abc\tdef\nghi'), 'Abc Def Ghi') |
| + self.assertEqual(string.capwords('abc\t def \nghi'), 'Abc Def Ghi') |
| + self.assertEqual(string.capwords('ABC DEF GHI'), 'Abc Def Ghi') |
| + self.assertEqual(string.capwords('ABC-DEF-GHI', '-'), 'Abc-Def-Ghi') |
| + self.assertEqual(string.capwords('ABC-def DEF-ghi GHI'), 'Abc-def Def-ghi Ghi') |
| + self.assertEqual(string.capwords(' aBc DeF '), 'Abc Def') |
| + self.assertEqual(string.capwords('\taBc\tDeF\t'), 'Abc Def') |
| + self.assertEqual(string.capwords('\taBc\tDeF\t', '\t'), '\tAbc\tDef\t') |
| + |
| + def test_basic_formatter(self): |
| + fmt = string.Formatter() |
| + self.assertEqual(fmt.format("foo"), "foo") |
| + self.assertEqual(fmt.format("foo{0}", "bar"), "foobar") |
| + self.assertEqual(fmt.format("foo{1}{0}-{1}", "bar", 6), "foo6bar-6") |
| + self.assertRaises(TypeError, fmt.format) |
| + self.assertRaises(TypeError, string.Formatter.format) |
| + |
| + def test_format_keyword_arguments(self): |
| + fmt = string.Formatter() |
| + self.assertEqual(fmt.format("-{arg}-", arg='test'), '-test-') |
| + self.assertRaises(KeyError, fmt.format, "-{arg}-") |
| + self.assertEqual(fmt.format("-{self}-", self='test'), '-test-') |
| + self.assertRaises(KeyError, fmt.format, "-{self}-") |
| + self.assertEqual(fmt.format("-{format_string}-", format_string='test'), |
| + '-test-') |
| + self.assertRaises(KeyError, fmt.format, "-{format_string}-") |
| + with self.assertRaisesRegex(TypeError, "format_string"): |
| + fmt.format(format_string="-{arg}-", arg='test') |
| + |
| + def test_auto_numbering(self): |
| + fmt = string.Formatter() |
| + self.assertEqual(fmt.format('foo{}{}', 'bar', 6), |
| + 'foo{}{}'.format('bar', 6)) |
| + self.assertEqual(fmt.format('foo{1}{num}{1}', None, 'bar', num=6), |
| + 'foo{1}{num}{1}'.format(None, 'bar', num=6)) |
| + self.assertEqual(fmt.format('{:^{}}', 'bar', 6), |
| + '{:^{}}'.format('bar', 6)) |
| + self.assertEqual(fmt.format('{:^{}} {}', 'bar', 6, 'X'), |
| + '{:^{}} {}'.format('bar', 6, 'X')) |
| + self.assertEqual(fmt.format('{:^{pad}}{}', 'foo', 'bar', pad=6), |
| + '{:^{pad}}{}'.format('foo', 'bar', pad=6)) |
| + |
| + with self.assertRaises(ValueError): |
| + fmt.format('foo{1}{}', 'bar', 6) |
| + |
| + with self.assertRaises(ValueError): |
| + fmt.format('foo{}{1}', 'bar', 6) |
| + |
| + def test_conversion_specifiers(self): |
| + fmt = string.Formatter() |
| + self.assertEqual(fmt.format("-{arg!r}-", arg='test'), "-'test'-") |
| + self.assertEqual(fmt.format("{0!s}", 'test'), 'test') |
| + self.assertRaises(ValueError, fmt.format, "{0!h}", 'test') |
| + # issue13579 |
| + self.assertEqual(fmt.format("{0!a}", 42), '42') |
| + self.assertEqual(fmt.format("{0!a}", string.ascii_letters), |
| + "'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'") |
| + self.assertEqual(fmt.format("{0!a}", chr(255)), "'\\xff'") |
| + self.assertEqual(fmt.format("{0!a}", chr(256)), "'\\u0100'") |
| + |
| + def test_name_lookup(self): |
| + fmt = string.Formatter() |
| + class AnyAttr: |
| + def __getattr__(self, attr): |
| + return attr |
| + x = AnyAttr() |
| + self.assertEqual(fmt.format("{0.lumber}{0.jack}", x), 'lumberjack') |
| + with self.assertRaises(AttributeError): |
| + fmt.format("{0.lumber}{0.jack}", '') |
| + |
| + def test_index_lookup(self): |
| + fmt = string.Formatter() |
| + lookup = ["eggs", "and", "spam"] |
| + self.assertEqual(fmt.format("{0[2]}{0[0]}", lookup), 'spameggs') |
| + with self.assertRaises(IndexError): |
| + fmt.format("{0[2]}{0[0]}", []) |
| + with self.assertRaises(KeyError): |
| + fmt.format("{0[2]}{0[0]}", {}) |
| + |
| + def test_auto_numbering_lookup(self): |
| + fmt = string.Formatter() |
| + namespace = types.SimpleNamespace(foo=types.SimpleNamespace(bar='baz')) |
| + widths = [None, types.SimpleNamespace(qux=4)] |
| + self.assertEqual( |
| + fmt.format("{.foo.bar:{[1].qux}}", namespace, widths), 'baz ') |
| + |
| + def test_auto_numbering_reenterability(self): |
| + class ReenteringFormatter(string.Formatter): |
| + def format_field(self, value, format_spec): |
| + if format_spec.isdigit() and int(format_spec) > 0: |
| + return self.format('{:{}}!', value, int(format_spec) - 1) |
| + else: |
| + return super().format_field(value, format_spec) |
| + fmt = ReenteringFormatter() |
| + x = types.SimpleNamespace(a='X') |
| + self.assertEqual(fmt.format('{.a:{}}', x, 3), 'X!!!') |
| + |
| + def test_override_get_value(self): |
| + class NamespaceFormatter(string.Formatter): |
| + def __init__(self, namespace={}): |
| + string.Formatter.__init__(self) |
| + self.namespace = namespace |
| + |
| + def get_value(self, key, args, kwds): |
| + if isinstance(key, str): |
| + try: |
| + # Check explicitly passed arguments first |
| + return kwds[key] |
| + except KeyError: |
| + return self.namespace[key] |
| + else: |
| + string.Formatter.get_value(key, args, kwds) |
| + |
| + fmt = NamespaceFormatter({'greeting':'hello'}) |
| + self.assertEqual(fmt.format("{greeting}, world!"), 'hello, world!') |
| + |
| + |
| + def test_override_format_field(self): |
| + class CallFormatter(string.Formatter): |
| + def format_field(self, value, format_spec): |
| + return format(value(), format_spec) |
| + |
| + fmt = CallFormatter() |
| + self.assertEqual(fmt.format('*{0}*', lambda : 'result'), '*result*') |
| + |
| + |
| + def test_override_convert_field(self): |
| + class XFormatter(string.Formatter): |
| + def convert_field(self, value, conversion): |
| + if conversion == 'x': |
| + return None |
| + return super().convert_field(value, conversion) |
| + |
| + fmt = XFormatter() |
| + self.assertEqual(fmt.format("{0!r}:{0!x}", 'foo', 'foo'), "'foo':None") |
| + |
| + |
| + def test_override_parse(self): |
| + class BarFormatter(string.Formatter): |
| + # returns an iterable that contains tuples of the form: |
| + # (literal_text, field_name, format_spec, conversion) |
| + def parse(self, format_string): |
| + for field in format_string.split('|'): |
| + if field[0] == '+': |
| + # it's markup |
| + field_name, _, format_spec = field[1:].partition(':') |
| + yield '', field_name, format_spec, None |
| + else: |
| + yield field, None, None, None |
| + |
| + fmt = BarFormatter() |
| + self.assertEqual(fmt.format('*|+0:^10s|*', 'foo'), '* foo *') |
| + |
| + def test_check_unused_args(self): |
| + class CheckAllUsedFormatter(string.Formatter): |
| + def check_unused_args(self, used_args, args, kwargs): |
| + # Track which arguments actually got used |
| + unused_args = set(kwargs.keys()) |
| + unused_args.update(range(0, len(args))) |
| + |
| + for arg in used_args: |
| + unused_args.remove(arg) |
| + |
| + if unused_args: |
| + raise ValueError("unused arguments") |
| + |
| + fmt = CheckAllUsedFormatter() |
| + self.assertEqual(fmt.format("{0}", 10), "10") |
| + self.assertEqual(fmt.format("{0}{i}", 10, i=100), "10100") |
| + self.assertEqual(fmt.format("{0}{i}{1}", 10, 20, i=100), "1010020") |
| + self.assertRaises(ValueError, fmt.format, "{0}{i}{1}", 10, 20, i=100, j=0) |
| + self.assertRaises(ValueError, fmt.format, "{0}", 10, 20) |
| + self.assertRaises(ValueError, fmt.format, "{0}", 10, 20, i=100) |
| + self.assertRaises(ValueError, fmt.format, "{i}", 10, 20, i=100) |
| + |
| + def test_vformat_recursion_limit(self): |
| + fmt = string.Formatter() |
| + args = () |
| + kwargs = dict(i=100) |
| + with self.assertRaises(ValueError) as err: |
| + fmt._vformat("{i}", args, kwargs, set(), -1) |
| + self.assertIn("recursion", str(err.exception)) |
| + |
| + |
| +# Template tests (formerly housed in test_pep292.py) |
| + |
| +class Bag: |
| + pass |
| + |
| +class Mapping: |
| + def __getitem__(self, name): |
| + obj = self |
| + for part in name.split('.'): |
| + try: |
| + obj = getattr(obj, part) |
| + except AttributeError: |
| + raise KeyError(name) |
| + return obj |
| + |
| + |
| +class TestTemplate(unittest.TestCase): |
| + def test_regular_templates(self): |
| + s = Template('$who likes to eat a bag of $what worth $$100') |
| + self.assertEqual(s.substitute(dict(who='tim', what='ham')), |
| + 'tim likes to eat a bag of ham worth $100') |
| + self.assertRaises(KeyError, s.substitute, dict(who='tim')) |
| + self.assertRaises(TypeError, Template.substitute) |
| + |
| + def test_regular_templates_with_braces(self): |
| + s = Template('$who likes ${what} for ${meal}') |
| + d = dict(who='tim', what='ham', meal='dinner') |
| + self.assertEqual(s.substitute(d), 'tim likes ham for dinner') |
| + self.assertRaises(KeyError, s.substitute, |
| + dict(who='tim', what='ham')) |
| + |
| + def test_regular_templates_with_upper_case(self): |
| + s = Template('$WHO likes ${WHAT} for ${MEAL}') |
| + d = dict(WHO='tim', WHAT='ham', MEAL='dinner') |
| + self.assertEqual(s.substitute(d), 'tim likes ham for dinner') |
| + |
| + def test_regular_templates_with_non_letters(self): |
| + s = Template('$_wh0_ likes ${_w_h_a_t_} for ${mea1}') |
| + d = dict(_wh0_='tim', _w_h_a_t_='ham', mea1='dinner') |
| + self.assertEqual(s.substitute(d), 'tim likes ham for dinner') |
| + |
| + def test_escapes(self): |
| + eq = self.assertEqual |
| + s = Template('$who likes to eat a bag of $$what worth $$100') |
| + eq(s.substitute(dict(who='tim', what='ham')), |
| + 'tim likes to eat a bag of $what worth $100') |
| + s = Template('$who likes $$') |
| + eq(s.substitute(dict(who='tim', what='ham')), 'tim likes $') |
| + |
| + def test_percents(self): |
| + eq = self.assertEqual |
| + s = Template('%(foo)s $foo ${foo}') |
| + d = dict(foo='baz') |
| + eq(s.substitute(d), '%(foo)s baz baz') |
| + eq(s.safe_substitute(d), '%(foo)s baz baz') |
| + |
| + def test_stringification(self): |
| + eq = self.assertEqual |
| + s = Template('tim has eaten $count bags of ham today') |
| + d = dict(count=7) |
| + eq(s.substitute(d), 'tim has eaten 7 bags of ham today') |
| + eq(s.safe_substitute(d), 'tim has eaten 7 bags of ham today') |
| + s = Template('tim has eaten ${count} bags of ham today') |
| + eq(s.substitute(d), 'tim has eaten 7 bags of ham today') |
| + |
| + def test_tupleargs(self): |
| + eq = self.assertEqual |
| + s = Template('$who ate ${meal}') |
| + d = dict(who=('tim', 'fred'), meal=('ham', 'kung pao')) |
| + eq(s.substitute(d), "('tim', 'fred') ate ('ham', 'kung pao')") |
| + eq(s.safe_substitute(d), "('tim', 'fred') ate ('ham', 'kung pao')") |
| + |
| + def test_SafeTemplate(self): |
| + eq = self.assertEqual |
| + s = Template('$who likes ${what} for ${meal}') |
| + eq(s.safe_substitute(dict(who='tim')), 'tim likes ${what} for ${meal}') |
| + eq(s.safe_substitute(dict(what='ham')), '$who likes ham for ${meal}') |
| + eq(s.safe_substitute(dict(what='ham', meal='dinner')), |
| + '$who likes ham for dinner') |
| + eq(s.safe_substitute(dict(who='tim', what='ham')), |
| + 'tim likes ham for ${meal}') |
| + eq(s.safe_substitute(dict(who='tim', what='ham', meal='dinner')), |
| + 'tim likes ham for dinner') |
| + |
| + def test_invalid_placeholders(self): |
| + raises = self.assertRaises |
| + s = Template('$who likes $') |
| + raises(ValueError, s.substitute, dict(who='tim')) |
| + s = Template('$who likes ${what)') |
| + raises(ValueError, s.substitute, dict(who='tim')) |
| + s = Template('$who likes $100') |
| + raises(ValueError, s.substitute, dict(who='tim')) |
| + # Template.idpattern should match to only ASCII characters. |
| + # https://bugs.python.org/issue31672 |
| + s = Template("$who likes $\u0131") # (DOTLESS I) |
| + raises(ValueError, s.substitute, dict(who='tim')) |
| + s = Template("$who likes $\u0130") # (LATIN CAPITAL LETTER I WITH DOT ABOVE) |
| + raises(ValueError, s.substitute, dict(who='tim')) |
| + |
| + def test_idpattern_override(self): |
| + class PathPattern(Template): |
| + idpattern = r'[_a-z][._a-z0-9]*' |
| + m = Mapping() |
| + m.bag = Bag() |
| + m.bag.foo = Bag() |
| + m.bag.foo.who = 'tim' |
| + m.bag.what = 'ham' |
| + s = PathPattern('$bag.foo.who likes to eat a bag of $bag.what') |
| + self.assertEqual(s.substitute(m), 'tim likes to eat a bag of ham') |
| + |
| + def test_flags_override(self): |
| + class MyPattern(Template): |
| + flags = 0 |
| + s = MyPattern('$wHO likes ${WHAT} for ${meal}') |
| + d = dict(wHO='tim', WHAT='ham', meal='dinner', w='fred') |
| + self.assertRaises(ValueError, s.substitute, d) |
| + self.assertEqual(s.safe_substitute(d), 'fredHO likes ${WHAT} for dinner') |
| + |
| + def test_idpattern_override_inside_outside(self): |
| + # bpo-1198569: Allow the regexp inside and outside braces to be |
| + # different when deriving from Template. |
| + class MyPattern(Template): |
| + idpattern = r'[a-z]+' |
| + braceidpattern = r'[A-Z]+' |
| + flags = 0 |
| + m = dict(foo='foo', BAR='BAR') |
| + s = MyPattern('$foo ${BAR}') |
| + self.assertEqual(s.substitute(m), 'foo BAR') |
| + |
| + def test_idpattern_override_inside_outside_invalid_unbraced(self): |
| + # bpo-1198569: Allow the regexp inside and outside braces to be |
| + # different when deriving from Template. |
| + class MyPattern(Template): |
| + idpattern = r'[a-z]+' |
| + braceidpattern = r'[A-Z]+' |
| + flags = 0 |
| + m = dict(foo='foo', BAR='BAR') |
| + s = MyPattern('$FOO') |
| + self.assertRaises(ValueError, s.substitute, m) |
| + s = MyPattern('${bar}') |
| + self.assertRaises(ValueError, s.substitute, m) |
| + |
| + def test_pattern_override(self): |
| + class MyPattern(Template): |
| + pattern = r""" |
| + (?P<escaped>@{2}) | |
| + @(?P<named>[_a-z][._a-z0-9]*) | |
| + @{(?P<braced>[_a-z][._a-z0-9]*)} | |
| + (?P<invalid>@) |
| + """ |
| + m = Mapping() |
| + m.bag = Bag() |
| + m.bag.foo = Bag() |
| + m.bag.foo.who = 'tim' |
| + m.bag.what = 'ham' |
| + s = MyPattern('@bag.foo.who likes to eat a bag of @bag.what') |
| + self.assertEqual(s.substitute(m), 'tim likes to eat a bag of ham') |
| + |
| + class BadPattern(Template): |
| + pattern = r""" |
| + (?P<badname>.*) | |
| + (?P<escaped>@{2}) | |
| + @(?P<named>[_a-z][._a-z0-9]*) | |
| + @{(?P<braced>[_a-z][._a-z0-9]*)} | |
| + (?P<invalid>@) | |
| + """ |
| + s = BadPattern('@bag.foo.who likes to eat a bag of @bag.what') |
| + self.assertRaises(ValueError, s.substitute, {}) |
| + self.assertRaises(ValueError, s.safe_substitute, {}) |
| + |
| + def test_braced_override(self): |
| + class MyTemplate(Template): |
| + pattern = r""" |
| + \$(?: |
| + (?P<escaped>$) | |
| + (?P<named>[_a-z][_a-z0-9]*) | |
| + @@(?P<braced>[_a-z][_a-z0-9]*)@@ | |
| + (?P<invalid>) | |
| + ) |
| + """ |
| + |
| + tmpl = 'PyCon in $@@location@@' |
| + t = MyTemplate(tmpl) |
| + self.assertRaises(KeyError, t.substitute, {}) |
| + val = t.substitute({'location': 'Cleveland'}) |
| + self.assertEqual(val, 'PyCon in Cleveland') |
| + |
| + def test_braced_override_safe(self): |
| + class MyTemplate(Template): |
| + pattern = r""" |
| + \$(?: |
| + (?P<escaped>$) | |
| + (?P<named>[_a-z][_a-z0-9]*) | |
| + @@(?P<braced>[_a-z][_a-z0-9]*)@@ | |
| + (?P<invalid>) | |
| + ) |
| + """ |
| + |
| + tmpl = 'PyCon in $@@location@@' |
| + t = MyTemplate(tmpl) |
| + self.assertEqual(t.safe_substitute(), tmpl) |
| + val = t.safe_substitute({'location': 'Cleveland'}) |
| + self.assertEqual(val, 'PyCon in Cleveland') |
| + |
| + def test_invalid_with_no_lines(self): |
| + # The error formatting for invalid templates |
| + # has a special case for no data that the default |
| + # pattern can't trigger (always has at least '$') |
| + # So we craft a pattern that is always invalid |
| + # with no leading data. |
| + class MyTemplate(Template): |
| + pattern = r""" |
| + (?P<invalid>) | |
| + unreachable( |
| + (?P<named>) | |
| + (?P<braced>) | |
| + (?P<escaped>) |
| + ) |
| + """ |
| + s = MyTemplate('') |
| + with self.assertRaises(ValueError) as err: |
| + s.substitute({}) |
| + self.assertIn('line 1, col 1', str(err.exception)) |
| + |
| + def test_unicode_values(self): |
| + s = Template('$who likes $what') |
| + d = dict(who='t\xffm', what='f\xfe\fed') |
| + self.assertEqual(s.substitute(d), 't\xffm likes f\xfe\x0ced') |
| + |
| + def test_keyword_arguments(self): |
| + eq = self.assertEqual |
| + s = Template('$who likes $what') |
| + eq(s.substitute(who='tim', what='ham'), 'tim likes ham') |
| + eq(s.substitute(dict(who='tim'), what='ham'), 'tim likes ham') |
| + eq(s.substitute(dict(who='fred', what='kung pao'), |
| + who='tim', what='ham'), |
| + 'tim likes ham') |
| + s = Template('the mapping is $mapping') |
| + eq(s.substitute(dict(foo='none'), mapping='bozo'), |
| + 'the mapping is bozo') |
| + eq(s.substitute(dict(mapping='one'), mapping='two'), |
| + 'the mapping is two') |
| + |
| + s = Template('the self is $self') |
| + eq(s.substitute(self='bozo'), 'the self is bozo') |
| + |
| + def test_keyword_arguments_safe(self): |
| + eq = self.assertEqual |
| + raises = self.assertRaises |
| + s = Template('$who likes $what') |
| + eq(s.safe_substitute(who='tim', what='ham'), 'tim likes ham') |
| + eq(s.safe_substitute(dict(who='tim'), what='ham'), 'tim likes ham') |
| + eq(s.safe_substitute(dict(who='fred', what='kung pao'), |
| + who='tim', what='ham'), |
| + 'tim likes ham') |
| + s = Template('the mapping is $mapping') |
| + eq(s.safe_substitute(dict(foo='none'), mapping='bozo'), |
| + 'the mapping is bozo') |
| + eq(s.safe_substitute(dict(mapping='one'), mapping='two'), |
| + 'the mapping is two') |
| + d = dict(mapping='one') |
| + raises(TypeError, s.substitute, d, {}) |
| + raises(TypeError, s.safe_substitute, d, {}) |
| + |
| + s = Template('the self is $self') |
| + eq(s.safe_substitute(self='bozo'), 'the self is bozo') |
| + |
| + def test_delimiter_override(self): |
| + eq = self.assertEqual |
| + raises = self.assertRaises |
| + class AmpersandTemplate(Template): |
| + delimiter = '&' |
| + s = AmpersandTemplate('this &gift is for &{who} &&') |
| + eq(s.substitute(gift='bud', who='you'), 'this bud is for you &') |
| + raises(KeyError, s.substitute) |
| + eq(s.safe_substitute(gift='bud', who='you'), 'this bud is for you &') |
| + eq(s.safe_substitute(), 'this &gift is for &{who} &') |
| + s = AmpersandTemplate('this &gift is for &{who} &') |
| + raises(ValueError, s.substitute, dict(gift='bud', who='you')) |
| + eq(s.safe_substitute(), 'this &gift is for &{who} &') |
| + |
| + class PieDelims(Template): |
| + delimiter = '@' |
| + s = PieDelims('@who likes to eat a bag of @{what} worth $100') |
| + self.assertEqual(s.substitute(dict(who='tim', what='ham')), |
| + 'tim likes to eat a bag of ham worth $100') |
| + |
| + def test_is_valid(self): |
| + eq = self.assertEqual |
| + s = Template('$who likes to eat a bag of ${what} worth $$100') |
| + self.assertTrue(s.is_valid()) |
| + |
| + s = Template('$who likes to eat a bag of ${what} worth $100') |
| + self.assertFalse(s.is_valid()) |
| + |
| + # if the pattern has an unrecognized capture group, |
| + # it should raise ValueError like substitute and safe_substitute do |
| + class BadPattern(Template): |
| + pattern = r""" |
| + (?P<badname>.*) | |
| + (?P<escaped>@{2}) | |
| + @(?P<named>[_a-z][._a-z0-9]*) | |
| + @{(?P<braced>[_a-z][._a-z0-9]*)} | |
| + (?P<invalid>@) | |
| + """ |
| + s = BadPattern('@bag.foo.who likes to eat a bag of @bag.what') |
| + self.assertRaises(ValueError, s.is_valid) |
| + |
| + def test_get_identifiers(self): |
| + eq = self.assertEqual |
| + raises = self.assertRaises |
| + s = Template('$who likes to eat a bag of ${what} worth $$100') |
| + ids = s.get_identifiers() |
| + eq(ids, ['who', 'what']) |
| + |
| + # repeated identifiers only included once |
| + s = Template('$who likes to eat a bag of ${what} worth $$100; ${who} likes to eat a bag of $what worth $$100') |
| + ids = s.get_identifiers() |
| + eq(ids, ['who', 'what']) |
| + |
| + # invalid identifiers are ignored |
| + s = Template('$who likes to eat a bag of ${what} worth $100') |
| + ids = s.get_identifiers() |
| + eq(ids, ['who', 'what']) |
| + |
| + # if the pattern has an unrecognized capture group, |
| + # it should raise ValueError like substitute and safe_substitute do |
| + class BadPattern(Template): |
| + pattern = r""" |
| + (?P<badname>.*) | |
| + (?P<escaped>@{2}) | |
| + @(?P<named>[_a-z][._a-z0-9]*) | |
| + @{(?P<braced>[_a-z][._a-z0-9]*)} | |
| + (?P<invalid>@) | |
| + """ |
| + s = BadPattern('@bag.foo.who likes to eat a bag of @bag.what') |
| + self.assertRaises(ValueError, s.get_identifiers) |
| + |
| + |
| +if __name__ == '__main__': |
| + unittest.main() |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,122 @@ |
| +import pickle |
| +import unittest |
| +from string.templatelib import Template, Interpolation |
| + |
| +from test.test_string._support import TStringBaseCase, fstring |
| + |
| + |
| +class TestTemplate(unittest.TestCase, TStringBaseCase): |
| + |
| + def test_common(self): |
| + self.assertEqual(type(t'').__name__, 'Template') |
| + self.assertEqual(type(t'').__qualname__, 'Template') |
| + self.assertEqual(type(t'').__module__, 'string.templatelib') |
| + |
| + a = 'a' |
| + i = t'{a}'.interpolations[0] |
| + self.assertEqual(type(i).__name__, 'Interpolation') |
| + self.assertEqual(type(i).__qualname__, 'Interpolation') |
| + self.assertEqual(type(i).__module__, 'string.templatelib') |
| + |
| + def test_basic_creation(self): |
| + # Simple t-string creation |
| + t = t'Hello, world' |
| + self.assertIsInstance(t, Template) |
| + self.assertTStringEqual(t, ('Hello, world',), ()) |
| + self.assertEqual(fstring(t), 'Hello, world') |
| + |
| + # Empty t-string |
| + t = t'' |
| + self.assertTStringEqual(t, ('',), ()) |
| + self.assertEqual(fstring(t), '') |
| + |
| + # Multi-line t-string |
| + t = t"""Hello, |
| +world""" |
| + self.assertEqual(t.strings, ('Hello,\nworld',)) |
| + self.assertEqual(len(t.interpolations), 0) |
| + self.assertEqual(fstring(t), 'Hello,\nworld') |
| + |
| + def test_creation_interleaving(self): |
| + # Should add strings on either side |
| + t = Template(Interpolation('Maria', 'name', None, '')) |
| + self.assertTStringEqual(t, ('', ''), [('Maria', 'name')]) |
| + self.assertEqual(fstring(t), 'Maria') |
| + |
| + # Should prepend empty string |
| + t = Template(Interpolation('Maria', 'name', None, ''), ' is my name') |
| + self.assertTStringEqual(t, ('', ' is my name'), [('Maria', 'name')]) |
| + self.assertEqual(fstring(t), 'Maria is my name') |
| + |
| + # Should append empty string |
| + t = Template('Hello, ', Interpolation('Maria', 'name', None, '')) |
| + self.assertTStringEqual(t, ('Hello, ', ''), [('Maria', 'name')]) |
| + self.assertEqual(fstring(t), 'Hello, Maria') |
| + |
| + # Should concatenate strings |
| + t = Template('Hello', ', ', Interpolation('Maria', 'name', None, ''), |
| + '!') |
| + self.assertTStringEqual(t, ('Hello, ', '!'), [('Maria', 'name')]) |
| + self.assertEqual(fstring(t), 'Hello, Maria!') |
| + |
| + # Should add strings on either side and in between |
| + t = Template(Interpolation('Maria', 'name', None, ''), |
| + Interpolation('Python', 'language', None, '')) |
| + self.assertTStringEqual( |
| + t, ('', '', ''), [('Maria', 'name'), ('Python', 'language')] |
| + ) |
| + self.assertEqual(fstring(t), 'MariaPython') |
| + |
| + def test_template_values(self): |
| + t = t'Hello, world' |
| + self.assertEqual(t.values, ()) |
| + |
| + name = "Lys" |
| + t = t'Hello, {name}' |
| + self.assertEqual(t.values, ("Lys",)) |
| + |
| + country = "GR" |
| + age = 0 |
| + t = t'Hello, {name}, {age} from {country}' |
| + self.assertEqual(t.values, ("Lys", 0, "GR")) |
| + |
| + def test_pickle_template(self): |
| + user = 'test' |
| + for template in ( |
| + t'', |
| + t"No values", |
| + t'With inter {user}', |
| + t'With ! {user!r}', |
| + t'With format {1 / 0.3:.2f}', |
| + Template(), |
| + Template('a'), |
| + Template(Interpolation('Nikita', 'name', None, '')), |
| + Template('a', Interpolation('Nikita', 'name', 'r', '')), |
| + ): |
| + for proto in range(pickle.HIGHEST_PROTOCOL + 1): |
| + with self.subTest(proto=proto, template=template): |
| + pickled = pickle.dumps(template, protocol=proto) |
| + unpickled = pickle.loads(pickled) |
| + |
| + self.assertEqual(unpickled.values, template.values) |
| + self.assertEqual(fstring(unpickled), fstring(template)) |
| + |
| + def test_pickle_interpolation(self): |
| + for interpolation in ( |
| + Interpolation('Nikita', 'name', None, ''), |
| + Interpolation('Nikita', 'name', 'r', ''), |
| + Interpolation(1/3, 'x', None, '.2f'), |
| + ): |
| + for proto in range(pickle.HIGHEST_PROTOCOL + 1): |
| + with self.subTest(proto=proto, interpolation=interpolation): |
| + pickled = pickle.dumps(interpolation, protocol=proto) |
| + unpickled = pickle.loads(pickled) |
| + |
| + self.assertEqual(unpickled.value, interpolation.value) |
| + self.assertEqual(unpickled.expression, interpolation.expression) |
| + self.assertEqual(unpickled.conversion, interpolation.conversion) |
| + self.assertEqual(unpickled.format_spec, interpolation.format_spec) |
| + |
| + |
| +if __name__ == '__main__': |
| + unittest.main() |
| |
| |
| |
| |
| @@ -1877,6 +1877,14 @@ |
| Traceback (most recent call last): |
| SyntaxError: cannot assign to f-string expression here. Maybe you meant '==' instead of '='? |
| |
| +>>> t'{x}' = 42 |
| +Traceback (most recent call last): |
| +SyntaxError: cannot assign to t-string expression here. Maybe you meant '==' instead of '='? |
| + |
| +>>> t'{x}-{y}' = 42 |
| +Traceback (most recent call last): |
| +SyntaxError: cannot assign to t-string expression here. Maybe you meant '==' instead of '='? |
| + |
| >>> (x, y, z=3, d, e) |
| Traceback (most recent call last): |
| SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='? |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,313 @@ |
| +import unittest |
| + |
| +from test.test_string._support import TStringBaseCase, fstring |
| + |
| + |
| +class TestTString(unittest.TestCase, TStringBaseCase): |
| + def test_string_representation(self): |
| + # Test __repr__ |
| + t = t"Hello" |
| + self.assertEqual(repr(t), "Template(strings=('Hello',), interpolations=())") |
| + |
| + name = "Python" |
| + t = t"Hello, {name}" |
| + self.assertEqual(repr(t), |
| + "Template(strings=('Hello, ', ''), " |
| + "interpolations=(Interpolation('Python', 'name', None, ''),))" |
| + ) |
| + |
| + def test_interpolation_basics(self): |
| + # Test basic interpolation |
| + name = "Python" |
| + t = t"Hello, {name}" |
| + self.assertTStringEqual(t, ("Hello, ", ""), [(name, "name")]) |
| + self.assertEqual(fstring(t), "Hello, Python") |
| + |
| + # Multiple interpolations |
| + first = "Python" |
| + last = "Developer" |
| + t = t"{first} {last}" |
| + self.assertTStringEqual( |
| + t, ("", " ", ""), [(first, 'first'), (last, 'last')] |
| + ) |
| + self.assertEqual(fstring(t), "Python Developer") |
| + |
| + # Interpolation with expressions |
| + a = 10 |
| + b = 20 |
| + t = t"Sum: {a + b}" |
| + self.assertTStringEqual(t, ("Sum: ", ""), [(a + b, "a + b")]) |
| + self.assertEqual(fstring(t), "Sum: 30") |
| + |
| + # Interpolation with function |
| + def square(x): |
| + return x * x |
| + t = t"Square: {square(5)}" |
| + self.assertTStringEqual( |
| + t, ("Square: ", ""), [(square(5), "square(5)")] |
| + ) |
| + self.assertEqual(fstring(t), "Square: 25") |
| + |
| + # Test attribute access in expressions |
| + class Person: |
| + def __init__(self, name): |
| + self.name = name |
| + |
| + def upper(self): |
| + return self.name.upper() |
| + |
| + person = Person("Alice") |
| + t = t"Name: {person.name}" |
| + self.assertTStringEqual( |
| + t, ("Name: ", ""), [(person.name, "person.name")] |
| + ) |
| + self.assertEqual(fstring(t), "Name: Alice") |
| + |
| + # Test method calls |
| + t = t"Name: {person.upper()}" |
| + self.assertTStringEqual( |
| + t, ("Name: ", ""), [(person.upper(), "person.upper()")] |
| + ) |
| + self.assertEqual(fstring(t), "Name: ALICE") |
| + |
| + # Test dictionary access |
| + data = {"name": "Bob", "age": 30} |
| + t = t"Name: {data['name']}, Age: {data['age']}" |
| + self.assertTStringEqual( |
| + t, ("Name: ", ", Age: ", ""), |
| + [(data["name"], "data['name']"), (data["age"], "data['age']")], |
| + ) |
| + self.assertEqual(fstring(t), "Name: Bob, Age: 30") |
| + |
| + def test_format_specifiers(self): |
| + # Test basic format specifiers |
| + value = 3.14159 |
| + t = t"Pi: {value:.2f}" |
| + self.assertTStringEqual( |
| + t, ("Pi: ", ""), [(value, "value", None, ".2f")] |
| + ) |
| + self.assertEqual(fstring(t), "Pi: 3.14") |
| + |
| + def test_conversions(self): |
| + # Test !s conversion (str) |
| + obj = object() |
| + t = t"Object: {obj!s}" |
| + self.assertTStringEqual(t, ("Object: ", ""), [(obj, "obj", "s")]) |
| + self.assertEqual(fstring(t), f"Object: {str(obj)}") |
| + |
| + # Test !r conversion (repr) |
| + t = t"Data: {obj!r}" |
| + self.assertTStringEqual(t, ("Data: ", ""), [(obj, "obj", "r")]) |
| + self.assertEqual(fstring(t), f"Data: {repr(obj)}") |
| + |
| + # Test !a conversion (ascii) |
| + text = "Café" |
| + t = t"ASCII: {text!a}" |
| + self.assertTStringEqual(t, ("ASCII: ", ""), [(text, "text", "a")]) |
| + self.assertEqual(fstring(t), f"ASCII: {ascii(text)}") |
| + |
| + # Test !z conversion (error) |
| + num = 1 |
| + with self.assertRaises(SyntaxError): |
| + eval("t'{num!z}'") |
| + |
| + def test_debug_specifier(self): |
| + # Test debug specifier |
| + value = 42 |
| + t = t"Value: {value=}" |
| + self.assertTStringEqual( |
| + t, ("Value: value=", ""), [(value, "value", "r")] |
| + ) |
| + self.assertEqual(fstring(t), "Value: value=42") |
| + |
| + # Test debug specifier with format (conversion default to !r) |
| + t = t"Value: {value=:.2f}" |
| + self.assertTStringEqual( |
| + t, ("Value: value=", ""), [(value, "value", None, ".2f")] |
| + ) |
| + self.assertEqual(fstring(t), "Value: value=42.00") |
| + |
| + # Test debug specifier with conversion |
| + t = t"Value: {value=!s}" |
| + self.assertTStringEqual( |
| + t, ("Value: value=", ""), [(value, "value", "s")] |
| + ) |
| + |
| + # Test white space in debug specifier |
| + t = t"Value: {value = }" |
| + self.assertTStringEqual( |
| + t, ("Value: value = ", ""), [(value, "value", "r")] |
| + ) |
| + self.assertEqual(fstring(t), "Value: value = 42") |
| + |
| + def test_raw_tstrings(self): |
| + path = r"C:\Users" |
| + t = rt"{path}\Documents" |
| + self.assertTStringEqual(t, ("", r"\Documents"), [(path, "path")]) |
| + self.assertEqual(fstring(t), r"C:\Users\Documents") |
| + |
| + # Test alternative prefix |
| + t = tr"{path}\Documents" |
| + self.assertTStringEqual(t, ("", r"\Documents"), [(path, "path")]) |
| + |
| + |
| + def test_template_concatenation(self): |
| + # Test template + template |
| + t1 = t"Hello, " |
| + t2 = t"world" |
| + combined = t1 + t2 |
| + self.assertTStringEqual(combined, ("Hello, world",), ()) |
| + self.assertEqual(fstring(combined), "Hello, world") |
| + |
| + # Test template + string |
| + t1 = t"Hello" |
| + combined = t1 + ", world" |
| + self.assertTStringEqual(combined, ("Hello, world",), ()) |
| + self.assertEqual(fstring(combined), "Hello, world") |
| + |
| + # Test template + template with interpolation |
| + name = "Python" |
| + t1 = t"Hello, " |
| + t2 = t"{name}" |
| + combined = t1 + t2 |
| + self.assertTStringEqual(combined, ("Hello, ", ""), [(name, "name")]) |
| + self.assertEqual(fstring(combined), "Hello, Python") |
| + |
| + # Test string + template |
| + t = "Hello, " + t"{name}" |
| + self.assertTStringEqual(t, ("Hello, ", ""), [(name, "name")]) |
| + self.assertEqual(fstring(t), "Hello, Python") |
| + |
| + def test_nested_templates(self): |
| + # Test a template inside another template expression |
| + name = "Python" |
| + inner = t"{name}" |
| + t = t"Language: {inner}" |
| + |
| + t_interp = t.interpolations[0] |
| + self.assertEqual(t.strings, ("Language: ", "")) |
| + self.assertEqual(t_interp.value.strings, ("", "")) |
| + self.assertEqual(t_interp.value.interpolations[0].value, name) |
| + self.assertEqual(t_interp.value.interpolations[0].expression, "name") |
| + self.assertEqual(t_interp.value.interpolations[0].conversion, None) |
| + self.assertEqual(t_interp.value.interpolations[0].format_spec, "") |
| + self.assertEqual(t_interp.expression, "inner") |
| + self.assertEqual(t_interp.conversion, None) |
| + self.assertEqual(t_interp.format_spec, "") |
| + |
| + def test_syntax_errors(self): |
| + for case, err in ( |
| + ("t'", "unterminated t-string literal"), |
| + ("t'''", "unterminated triple-quoted t-string literal"), |
| + ("t''''", "unterminated triple-quoted t-string literal"), |
| + ("t'{", "'{' was never closed"), |
| + ("t'{'", "t-string: expecting '}'"), |
| + ("t'{a'", "t-string: expecting '}'"), |
| + ("t'}'", "t-string: single '}' is not allowed"), |
| + ("t'{}'", "t-string: valid expression required before '}'"), |
| + ("t'{=x}'", "t-string: valid expression required before '='"), |
| + ("t'{!x}'", "t-string: valid expression required before '!'"), |
| + ("t'{:x}'", "t-string: valid expression required before ':'"), |
| + ("t'{x;y}'", "t-string: expecting '=', or '!', or ':', or '}'"), |
| + ("t'{x=y}'", "t-string: expecting '!', or ':', or '}'"), |
| + ("t'{x!s!}'", "t-string: expecting ':' or '}'"), |
| + ("t'{x!s:'", "t-string: expecting '}', or format specs"), |
| + ("t'{x!}'", "t-string: missing conversion character"), |
| + ("t'{x=!}'", "t-string: missing conversion character"), |
| + ("t'{x!z}'", "t-string: invalid conversion character 'z': " |
| + "expected 's', 'r', or 'a'"), |
| + ("t'{lambda:1}'", "t-string: lambda expressions are not allowed " |
| + "without parentheses"), |
| + ("t'{x:{;}}'", "t-string: expecting a valid expression after '{'"), |
| + ): |
| + with self.subTest(case), self.assertRaisesRegex(SyntaxError, err): |
| + eval(case) |
| + |
| + def test_runtime_errors(self): |
| + # Test missing variables |
| + with self.assertRaises(NameError): |
| + eval("t'Hello, {name}'") |
| + |
| + def test_literal_concatenation(self): |
| + # Test concatenation of t-string literals |
| + t = t"Hello, " t"world" |
| + self.assertTStringEqual(t, ("Hello, world",), ()) |
| + self.assertEqual(fstring(t), "Hello, world") |
| + |
| + # Test concatenation with interpolation |
| + name = "Python" |
| + t = t"Hello, " t"{name}" |
| + self.assertTStringEqual(t, ("Hello, ", ""), [(name, "name")]) |
| + self.assertEqual(fstring(t), "Hello, Python") |
| + |
| + # Test concatenation with string literal |
| + name = "Python" |
| + t = t"Hello, {name}" "and welcome!" |
| + self.assertTStringEqual( |
| + t, ("Hello, ", "and welcome!"), [(name, "name")] |
| + ) |
| + self.assertEqual(fstring(t), "Hello, Pythonand welcome!") |
| + |
| + # Test concatenation with Unicode literal |
| + name = "Python" |
| + t = t"Hello, {name}" u"and welcome!" |
| + self.assertTStringEqual( |
| + t, ("Hello, ", "and welcome!"), [(name, "name")] |
| + ) |
| + self.assertEqual(fstring(t), "Hello, Pythonand welcome!") |
| + |
| + # Test concatenation with f-string literal |
| + tab = '\t' |
| + t = t"Tab: {tab}. " f"f-tab: {tab}." |
| + self.assertTStringEqual(t, ("Tab: ", ". f-tab: \t."), [(tab, "tab")]) |
| + self.assertEqual(fstring(t), "Tab: \t. f-tab: \t.") |
| + |
| + # Test concatenation with raw string literal |
| + tab = '\t' |
| + t = t"Tab: {tab}. " r"Raw tab: \t." |
| + self.assertTStringEqual( |
| + t, ("Tab: ", r". Raw tab: \t."), [(tab, "tab")] |
| + ) |
| + self.assertEqual(fstring(t), "Tab: \t. Raw tab: \\t.") |
| + |
| + # Test concatenation with raw f-string literal |
| + tab = '\t' |
| + t = t"Tab: {tab}. " rf"f-tab: {tab}. Raw tab: \t." |
| + self.assertTStringEqual( |
| + t, ("Tab: ", ". f-tab: \t. Raw tab: \\t."), [(tab, "tab")] |
| + ) |
| + self.assertEqual(fstring(t), "Tab: \t. f-tab: \t. Raw tab: \\t.") |
| + |
| + what = 't' |
| + expected_msg = 'cannot mix bytes and nonbytes literals' |
| + for case in ( |
| + "t'{what}-string literal' b'bytes literal'", |
| + "t'{what}-string literal' br'raw bytes literal'", |
| + ): |
| + with self.assertRaisesRegex(SyntaxError, expected_msg): |
| + eval(case) |
| + |
| + def test_triple_quoted(self): |
| + # Test triple-quoted t-strings |
| + t = t""" |
| + Hello, |
| + world |
| + """ |
| + self.assertTStringEqual( |
| + t, ("\n Hello,\n world\n ",), () |
| + ) |
| + self.assertEqual(fstring(t), "\n Hello,\n world\n ") |
| + |
| + # Test triple-quoted with interpolation |
| + name = "Python" |
| + t = t""" |
| + Hello, |
| + {name} |
| + """ |
| + self.assertTStringEqual( |
| + t, ("\n Hello,\n ", "\n "), [(name, "name")] |
| + ) |
| + self.assertEqual(fstring(t), "\n Hello,\n Python\n ") |
| + |
| +if __name__ == '__main__': |
| + unittest.main() |
| |
| |
| |
| |
| @@ -202,6 +202,15 @@ def test_fstrings_pep701(self): |
| self.check_ast_roundtrip('f" something { my_dict["key"] } something else "') |
| self.check_ast_roundtrip('f"{f"{f"{f"{f"{f"{1+1}"}"}"}"}"}"') |
| |
| + def test_tstrings(self): |
| + self.check_ast_roundtrip("t'foo'") |
| + self.check_ast_roundtrip("t'foo {bar}'") |
| + self.check_ast_roundtrip("t'foo {bar!s:.2f}'") |
| + self.check_ast_roundtrip("t'foo {bar}' f'{bar}'") |
| + self.check_ast_roundtrip("f'{bar}' t'foo {bar}'") |
| + self.check_ast_roundtrip("t'foo {bar}' fr'\\hello {bar}'") |
| + self.check_ast_roundtrip("t'foo {bar}' u'bar'") |
| + |
| def test_strings(self): |
| self.check_ast_roundtrip("u'foo'") |
| self.check_ast_roundtrip("r'foo'") |
| @@ -918,7 +927,7 @@ class DirectoryTestCase(ASTTestCase): |
| run_always_files = {"test_grammar.py", "test_syntax.py", "test_compile.py", |
| "test_ast.py", "test_asdl_parser.py", "test_fstring.py", |
| "test_patma.py", "test_type_alias.py", "test_type_params.py", |
| - "test_tokenize.py"} |
| + "test_tokenize.py", "test_tstring.py"} |
| |
| _files_to_test = None |
| |
|
|
