Rename f helper to fstring

Author: lysnikolaou

Lib/test/test_string/_support.py

@@ -42,7 +42,7 @@ def convert(value, conversion):
     return value
 
 
-def f(template):
+def fstring(template):
     parts = []
     for item in template:
         match item:

Lib/test/test_string/test_templatelib.py

@@ -1,6 +1,6 @@
 from string.templatelib import Template, Interpolation
 
-from test.test_string._support import TStringTestCase, f
+from test.test_string._support import TStringTestCase, fstring
 
 
 class TestTemplate(TStringTestCase):
@@ -10,46 +10,46 @@ def test_basic_creation(self):
         t = t'Hello, world'
         self.assertIsInstance(t, Template)
         self.assertTStringEqual(t, ('Hello, world',), ())
-        self.assertEqual(f(t), 'Hello, world')
+        self.assertEqual(fstring(t), 'Hello, world')
 
         # Empty t-string
         t = t''
         self.assertTStringEqual(t, ('',), ())
-        self.assertEqual(f(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(f(t), 'Hello,\nworld')
+        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(f(t), 'Maria')
+        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(f(t), 'Maria is my 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(f(t), 'Hello, Maria')
+        self.assertEqual(fstring(t), 'Hello, Maria')
 
         # Should concatenate strings
         t = Template('Hello', ', ', Interpolation('Maria', 'name', None, ''),
                      '!')
         self.assertTStringEqual(t, ('Hello, ', '!'), [('Maria', 'name')])
-        self.assertEqual(f(t), 'Hello, Maria!')
+        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(f(t), 'MariaPython')
+        self.assertEqual(fstring(t), 'MariaPython')

Lib/test/test_tstring.py

@@ -1,7 +1,7 @@
 import ast
 import unittest
 
-from test.test_string._support import TStringTestCase, f
+from test.test_string._support import TStringTestCase, fstring
 
 
 class TestTString(TStringTestCase):
@@ -28,7 +28,7 @@ def test_interpolation_basics(self):
         name = "Python"
         t = t"Hello, {name}"
         self.assertTStringEqual(t, ("Hello, ", ""), [(name, "name")])
-        self.assertEqual(f(t), "Hello, Python")
+        self.assertEqual(fstring(t), "Hello, Python")
 
         # Multiple interpolations
         first = "Python"
@@ -37,14 +37,14 @@ def test_interpolation_basics(self):
         self.assertTStringEqual(
             t, ("", " ", ""), [(first, 'first'), (last, 'last')]
         )
-        self.assertEqual(f(t), "Python Developer")
+        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(f(t), "Sum: 30")
+        self.assertEqual(fstring(t), "Sum: 30")
 
         # Interpolation with function
         def square(x):
@@ -53,7 +53,7 @@ def square(x):
         self.assertTStringEqual(
             t, ("Square: ", ""), [(square(5), "square(5)")]
         )
-        self.assertEqual(f(t), "Square: 25")
+        self.assertEqual(fstring(t), "Square: 25")
 
         # Test attribute access in expressions
         class Person:
@@ -68,14 +68,14 @@ def upper(self):
         self.assertTStringEqual(
             t, ("Name: ", ""), [(person.name, "person.name")]
         )
-        self.assertEqual(f(t), "Name: Alice")
+        self.assertEqual(fstring(t), "Name: Alice")
 
         # Test method calls
         t = t"Name: {person.upper()}"
         self.assertTStringEqual(
             t, ("Name: ", ""), [(person.upper(), "person.upper()")]
         )
-        self.assertEqual(f(t), "Name: ALICE")
+        self.assertEqual(fstring(t), "Name: ALICE")
 
         # Test dictionary access
         data = {"name": "Bob", "age": 30}
@@ -84,7 +84,7 @@ def upper(self):
             t, ("Name: ", ", Age: ", ""),
             [(data["name"], "data['name']"), (data["age"], "data['age']")],
         )
-        self.assertEqual(f(t), "Name: Bob, Age: 30")
+        self.assertEqual(fstring(t), "Name: Bob, Age: 30")
 
     def test_format_specifiers(self):
         # Test basic format specifiers
@@ -93,25 +93,25 @@ def test_format_specifiers(self):
         self.assertTStringEqual(
             t, ("Pi: ", ""), [(value, "value", None, ".2f")]
         )
-        self.assertEqual(f(t), "Pi: 3.14")
+        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(f(t), f"Object: {str(obj)}")
+        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(f(t), f"Data: {repr(obj)}")
+        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(f(t), f"ASCII: {ascii(text)}")
+        self.assertEqual(fstring(t), f"ASCII: {ascii(text)}")
 
         # Test !z conversion (error)
         num = 1
@@ -125,14 +125,14 @@ def test_debug_specifier(self):
         self.assertTStringEqual(
             t, ("Value: value=", ""), [(value, "value", "r")]
         )
-        self.assertEqual(f(t), "Value: value=42")
+        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(f(t), "Value: value=42.00")
+        self.assertEqual(fstring(t), "Value: value=42.00")
 
         # Test debug specifier with conversion
         t = t"Value: {value=!s}"
@@ -145,13 +145,13 @@ def test_debug_specifier(self):
         self.assertTStringEqual(
             t, ("Value: value = ", ""), [(value, "value", "r")]
         )
-        self.assertEqual(f(t), "Value: value = 42")
+        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(f(t), r"C:\Users\Documents")
+        self.assertEqual(fstring(t), r"C:\Users\Documents")
 
         # Test alternative prefix
         t = tr"{path}\Documents"
@@ -164,26 +164,26 @@ def test_template_concatenation(self):
         t2 = t"world"
         combined = t1 + t2
         self.assertTStringEqual(combined, ("Hello, world",), ())
-        self.assertEqual(f(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(f(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(f(combined), "Hello, Python")
+        self.assertEqual(fstring(combined), "Hello, Python")
 
         # Test string + template
         t = "Hello, " + t"{name}"
         self.assertTStringEqual(t, ("Hello, ", ""), [(name, "name")])
-        self.assertEqual(f(t), "Hello, Python")
+        self.assertEqual(fstring(t), "Hello, Python")
 
     def test_nested_templates(self):
         # Test a template inside another template expression
@@ -251,51 +251,51 @@ def test_literal_concatenation(self):
         # Test concatenation of t-string literals
         t = t"Hello, " t"world"
         self.assertTStringEqual(t, ("Hello, world",), ())
-        self.assertEqual(f(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(f(t), "Hello, Python")
+        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(f(t), "Hello, Pythonand welcome!")
+        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(f(t), "Hello, Pythonand welcome!")
+        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(f(t), "Tab: \t. f-tab: \t.")
+        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(f(t), "Tab: \t. Raw tab: \\t.")
+        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(f(t), "Tab: \t. f-tab: \t. Raw tab: \\t.")
+        self.assertEqual(fstring(t), "Tab: \t. f-tab: \t. Raw tab: \\t.")
 
         what = 't'
         expected_msg = 'cannot mix bytes and nonbytes literals'
@@ -315,7 +315,7 @@ def test_triple_quoted(self):
         self.assertTStringEqual(
             t, ("\n        Hello,\n        world\n        ",), ()
         )
-        self.assertEqual(f(t), "\n        Hello,\n        world\n        ")
+        self.assertEqual(fstring(t), "\n        Hello,\n        world\n        ")
 
         # Test triple-quoted with interpolation
         name = "Python"
@@ -326,7 +326,7 @@ def test_triple_quoted(self):
         self.assertTStringEqual(
             t, ("\n        Hello,\n        ", "\n        "), [(name, "name")]
         )
-        self.assertEqual(f(t), "\n        Hello,\n        Python\n        ")
+        self.assertEqual(fstring(t), "\n        Hello,\n        Python\n        ")
 
 if __name__ == '__main__':
     unittest.main()