Update all tests to match PEP 750 spec. (#10)

Author: davepeck

.devcontainer/Dockerfile

@@ -1,4 +1,4 @@
-FROM koxudaxi/python:3.14.0a1-tstrings-b0dbe27-bullseye
+FROM ghcr.io/davepeck/python:davepeck-ts-iter-fix
 
 # # Allow PYO3 to build even though the configured interpreter version (3.14)
 # # is greater than PYO3's stated limit (3.12)

pep/__init__.py

@@ -17,12 +17,6 @@
 _MISSING_TEMPLATE_ADD_RADD = False  # 🎉
 """True if the cpython prototype is missing __add__ and __radd__ for Template."""
 
-_MISSING_TEMPLATE_EQ = False  # 🎉
-"""True if the cpython prototype is missing an updated __eq__ for Template."""
-
-_MISSING_TEMPLATE_HASH = False  # 🎉
-"""True if the cpython prototype is missing __hash__ for Template."""
-
 _MISSING_INTERLEAVING = False  # 🎉
 """True if the cpython prototype doesn't interleave strings and interpolations."""
 

pep/afstring.py

@@ -6,7 +6,7 @@
 
 import inspect
 
-from templatelib import Interpolation, Template
+from string.templatelib import Interpolation, Template
 
 from .fstring import convert
 
@@ -21,8 +21,8 @@ async def async_f(template: Template) -> str:
     formatting it.
     """
     parts = []
-    for arg in template.args:
-        match arg:
+    for item in template:
+        match item:
             case str() as s:
                 parts.append(s)
             case Interpolation(value, _, conv, format_spec):

pep/format.py

@@ -7,7 +7,7 @@
 import string
 from typing import Literal
 
-from templatelib import Interpolation, Template
+from string.templatelib import Interpolation, Template
 
 
 def _split_field_name(field_name: str) -> tuple[str, str]:

pep/fstring.py

@@ -11,30 +11,30 @@
 
 from typing import Literal
 
-from templatelib import Interpolation, Template
+from string.templatelib import Interpolation, Template
 
 
-def convert(value: object, conv: Literal["a", "r", "s"] | None) -> object:
+def convert(value: object, conversion: Literal["a", "r", "s"] | None) -> object:
     """Convert the value to a string using the specified conversion."""
     # Python has no convert() built-in function, so we have to implement it.
-    if conv == "a":
+    if conversion == "a":
         return ascii(value)
-    if conv == "r":
+    if conversion == "r":
         return repr(value)
-    if conv == "s":
+    if conversion == "s":
         return str(value)
     return value
 
 
 def f(template: Template) -> str:
     """Implement f-string behavior using the PEP 750 t-string behavior."""
     parts = []
-    for arg in template.args:
-        match arg:
+    for item in template:
+        match item:
             case str() as s:
                 parts.append(s)
-            case Interpolation(value, _, conv, format_spec):
-                value = convert(value, conv)
+            case Interpolation(value, _, conversion, format_spec):
+                value = convert(value, conversion)
                 value = format(value, format_spec)
                 parts.append(value)
     return "".join(parts)

pep/lazy.py

@@ -1,6 +1,6 @@
 """Examples of lazy evaluation in templates."""
 
-from templatelib import Template
+from string.templatelib import Template
 
 from .fstring import convert
 
@@ -18,15 +18,15 @@ def format_some(selector: str, template: Template, ignored: str = "***") -> str:
     unnecessary.
     """
     parts = []
-    for t_arg in template.args:
-        if isinstance(t_arg, str):
-            parts.append(t_arg)
+    for item in template:
+        if isinstance(item, str):
+            parts.append(item)
         else:
-            if t_arg.format_spec == selector:
-                value = t_arg.value
+            if item.format_spec == selector:
+                value = item.value
                 if callable(value):
                     value = value()
-                value = convert(value, t_arg.conv)
+                value = convert(value, item.conversion)
             else:
                 value = ignored
             parts.append(value)

pep/logging.py

@@ -10,7 +10,7 @@
 from logging import Formatter, LogRecord
 from typing import Any, Literal, Mapping, Protocol
 
-from templatelib import Interpolation, Template
+from string.templatelib import Interpolation, Template
 
 from .fstring import f
 
@@ -36,9 +36,9 @@ def message(self) -> str:
     @property
     def values(self) -> Mapping[str, object]:
         return {
-            arg.expr: arg.value
-            for arg in self.template.args
-            if isinstance(arg, Interpolation)
+            item.expression: item.value
+            for item in self.template
+            if isinstance(item, Interpolation)
         }
 
     @property
@@ -104,9 +104,9 @@ class ValuesFormatter(TemplateFormatterBase):
 
     def values(self, template: Template) -> Mapping[str, object]:
         return {
-            arg.expr: arg.value
-            for arg in template.args
-            if isinstance(arg, Interpolation)
+            item.expression: item.value
+            for item in template
+            if isinstance(item, Interpolation)
         }
 
     def format(self, record: LogRecord) -> str:

pep/reuse.py

@@ -7,7 +7,7 @@
 values?
 """
 
-from templatelib import Interpolation, Template
+from string.templatelib import Interpolation, Template
 
 from .fstring import convert
 
@@ -23,23 +23,23 @@ class Formatter:
     def __init__(self, template: Template):
         """Construct a formatter for the provided template."""
         # Ensure that all interpolations are strings.
-        for arg in template.args:
-            if isinstance(arg, Interpolation):
-                if not isinstance(arg.value, str):
-                    raise ValueError(f"Non-string interpolation: {arg.value}")
+        for item in template:
+            if isinstance(item, Interpolation):
+                if not isinstance(item.value, str):
+                    raise ValueError(f"Non-string interpolation: {item.value}")
         self.template = template
 
     def format(self, **kwargs) -> str:
         """Render the t-string using the given values."""
         parts = []
-        for t_arg in self.template.args:
-            if isinstance(t_arg, str):
-                parts.append(t_arg)
+        for item in self.template:
+            if isinstance(item, str):
+                parts.append(item)
             else:
-                assert isinstance(t_arg.value, str)
-                value = kwargs[t_arg.value]
-                value = convert(value, t_arg.conv)
-                value = format(value, t_arg.format_spec)
+                assert isinstance(item.value, str)
+                value = kwargs[item.value]
+                value = convert(value, item.conversion)
+                value = format(value, item.format_spec)
                 parts.append(value)
         return "".join(parts)
 
@@ -55,24 +55,24 @@ class Binder:
     def __init__(self, template: Template):
         """Construct a binder for the provided template."""
         # Ensure that all interpolations are strings.
-        for arg in template.args:
-            if isinstance(arg, Interpolation):
-                if not isinstance(arg.value, str):
-                    raise ValueError(f"Non-string interpolation: {arg.value}")
+        for item in template:
+            if isinstance(item, Interpolation):
+                if not isinstance(item.value, str):
+                    raise ValueError(f"Non-string interpolation: {item.value}")
         self.template = template
 
     def bind(self, **kwargs) -> Template:
         """Bind values to the template."""
-        args = []
-        for t_arg in self.template.args:
-            if isinstance(t_arg, str):
-                args.append(t_arg)
+        items = []
+        for item in self.template:
+            if isinstance(item, str):
+                items.append(item)
             else:
-                assert isinstance(t_arg.value, str)
-                value = kwargs[t_arg.value]
-                expr = repr(t_arg.value)[1:-1]  # remove quotes from original expression
+                assert isinstance(item.value, str)
+                value = kwargs[item.value]
+                expr = repr(item.value)[1:-1]  # remove quotes from original expression
                 interpolation = Interpolation(
-                    value, expr, t_arg.conv, t_arg.format_spec
+                    value, expr, item.conversion, item.format_spec
                 )
-                args.append(interpolation)
-        return Template(*args)
+                items.append(interpolation)
+        return Template(*items)