Clean up repository now that Python 3.14 is out. (#16)

Author: davepeck

.devcontainer/Dockerfile

@@ -6,23 +6,23 @@ name: Test
 on:
   push:
     branches:
-      - '*'
-  workflow_dispatch:  # Allows manual triggering of the workflow
-
+      - "*"
+  workflow_dispatch: # Allows manual triggering of the workflow
 
 jobs:
-    test:
-        runs-on: ubuntu-latest
-        steps:
-          - name: Checkout repository
-            uses: actions/checkout@v4
-          # TODO: fix this stuff -- no longer working for some reason. -Dave
-          # - name: Build Docker image
-          #   run: docker build -t pep750-docker -f .devcontainer/Dockerfile .
-          # - name: Check sort order
-          #   run: docker run -v $(pwd):/app -w /app pep750-docker /bin/bash -c "pip install -r requirements.txt && isort --check pep"
-          # - name: Check formatting
-          #   run: docker run -v $(pwd):/app -w /app pep750-docker /bin/bash -c "pip install -r requirements.txt && black --check pep"
-          # - name: Run tests
-          #   run: docker run -v $(pwd):/app -w /app pep750-docker /bin/bash -c "pip install -r requirements.txt && pytest"
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v5
+
+      - name: Set up Python 3.14
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.14"
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
 
+      - name: Run tests
+        run: uv run pytest

.devcontainer/devcontainer.json

@@ -1,7 +1,7 @@
 {
-    "python.testing.pytestArgs": [
-        "pep"
-    ],
-    "python.testing.unittestEnabled": false,
-    "python.testing.pytestEnabled": true
+  "python.testing.pytestArgs": ["pep"],
+  "python.testing.unittestEnabled": false,
+  "python.testing.pytestEnabled": true,
+  "python.terminal.activateEnvInCurrentTerminal": false,
+  "python.terminal.activateEnvironment": false
 }

.github/workflows/test.yml

@@ -4,36 +4,11 @@ This repository contains full implementations of the code examples described in
 
 ## Running This Code
 
-This repo has a [devcontainer](https://containers.dev) definition that makes it easy to run the examples. The devcontainer includes a [fork of cpython 3.14a7+](https://github.com/lysnikolaou/cpython/tree/tstrings) that provides a prototype implementation of PEP 750.
+You'll need [Python 3.14](https://www.python.org/downloads/release/python-3140/), which was released in October 2025, and includes support for t-strings.
 
-It's easy to run this code yourself:
+If you have [Astral's `uv`](https://docs.astral.sh/uv/) installed, you can run 3.14 in an isolated environment with `uv run --python 3.14 python`.
 
-1. Make sure you have Docker installed
-2. Clone this repository and open it with `vscode`
-3. When asked, say that you want to re-open _inside_ the devcontainer
-
-After the container is initialized, make sure that everything works by opening up a terminal in vscode. This will open in the running docker instance. Then:
-
-```
-/workspaces/pep750-examples# python --version
-Python 3.14.0a7+
-/workspaces/pep750-examples# pytest
-... (hopefully, all tests pass!) ...
-```
-
-Congrats; you're good to go!
-
-## A Word About the Code
-
-This repository builds on top of the @lysnikolaou's [cpython branch implementing t-strings](https://github.com/lysnikolaou/cpython/tree/tstrings).
-
-### Linting, formatting, etc.
-
-The included devcontainer loads my [fork of black with t-string support](https://github.com/davepeck/black/tree/pep750-support).
-
-`isort` is used.
-
-Tools like `mypy` and friends can't type check t-strings yet, hence the many extra `: Template` annotations sprinkled throughout the code.
+You can run tests on this repository `uv run pytest`.
 
 ## Examples
 
@@ -48,6 +23,7 @@ templated = t"Hello {name!r}, value: {value:.2f}"
 formatted = f"Hello {name!r}, value: {value:.2f}"
 assert f(templated) == formatted
 ```
+
 See also [the tests](./pep/test_fstring.py).
 
 This [example is described in detail](https://peps.python.org/pep-0750/#example-implementing-f-strings-with-t-strings) in PEP 750.
@@ -85,7 +61,6 @@ See the tests in [`test_logging.py`](./pep/test_logging.py).
 
 This [example is described in detail](https://peps.python.org/pep-0750/#example-structured-logging) in PEP 750.
 
-
 ### Working with old-style format strings
 
 The code in [`format.py`](./pep/format.py) shows how to convert old-style format
@@ -101,133 +76,12 @@ assert f(as_template) == "Thank you Alice for spending $42.00."
 
 The `from_format()` function supports essentially all the features of old-style format strings, including positional and keyword arguments, automatic and manual field numbering, index and dot interpolation notation, nested format specifiers, and more.
 
-
 ### HTML Templating
 
 There are several short "HTML templating" examples in [PEP 750](https://peps.python.org/pep-0750/).
 
 They all use a hypothetical `html()` function that parses template strings to an intermediate type, `Element`, and supports context-dependent processing of interpolations.
 
-A real working implementation of `html()` is found in this repository's [`web.py`](./pep/web.py). Corresponding tests are found in [`test_web.py`](./pep/test_web.py).
-
-Building a full robust HTML templating package on top of template strings is both a noble goal _and_ beyond the scope of this example code. Instead, our goal is to hint at some interesting uses of template strings in the HTML context, and to provide an early roadmap (warts and all) for how a more robust package might be built.
-
-The `Element` class is a simple representation of an HTML element:
-
-```python
-
-from dataclasses import dataclass
-
-@dataclass(frozen=True)
-class Element:
-    """A simple representation of an HTML element."""
-
-    tag: str  # An empty string indicates a fragment
-    attributes: Mapping[str, str | None]
-    children: Sequence[str | Element]
-
-    def __str__(self) -> str:
-        ...
-```
-
-Elements can be converted to strings:
-
-```python
-element = Element(tag="p", attributes={}, children=["hello"])
-assert str(element) == "<p>hello</p>"
-
-element2 = Element(tag="div", attributes={"id": "main"}, children=[element])
-assert str(element2) == '<div id="main"><p>hello</p></div>'
-```
-
-The `html()` function parses PEP 750 template strings to an `Element`:
-
-```python
-def html(template: Template) -> Element:
-    ...
-
-assert html(t"<p>hello</p>") == Element(tag="p", attributes={}, children=["hello"])
-```
-
-The `html()` function supports several features that decide how interpolations are processed based both on their type _and_ their position in the HTML syntax.
-
-Content can be interpolated into the body of an element:
-
-```python
-text = "Hello, World!"
-element = html(t"<p>{text}</p>")
-assert str(element) == "<p>Hello, World!</p>"
-```
-
-When content is interpolated, it is also automatically escaped:
-
-```python
-evil = "<script>alert('evil')</script>"
-element = html(t"<p>{evil}</p>")
-assert str(element) == "<p>&lt;script&gt;alert('evil')&lt;/script&gt;</p>"
-```
-
-Attribute values can be interpolated:
-
-```python
-src = "shrubbery.jpg"
-element = html(t'<img src={src} />')
-assert str(element) == '<img src="shrubbery.jpg" />'
-```
-
-Multiple attributes can be interpolated at once:
-
-```python
-attributes = {"src": "shrubbery.jpg", "alt": "A shrubbery"}
-element = html(t'<img {attributes} />')
-assert str(element) == '<img src="shrubbery.jpg" alt="A shrubbery" />'
-```
-
-Boolean attributes are also supported:
-
-```python
-attributes = {"type": "text", "required": True}
-element = html(t'<input {attributes} />')
-assert str(element) == '<input type="text" required />'
-```
-
-HTML `Element` instances can be nested:
-
-```python
-item1 = html(t"<li>Item 1</li>")
-item2 = html(t"<li>Item 2</li>")
-element = html(t"<ul>{item1}{item2}</ul>")
-assert str(element) == "<ul><li>Item 1</li><li>Item 2</li></ul>"
-```
-
-As a convenience, `html()` also supports a simplification for nesting: if an interpolation's value is a `Template`, it is automatically converted to an `Element`:
-
-```python
-item1 = t"<li>Item 1</li>"
-item2 = t"<li>Item 2</li>"
-element = html(t"<ul>{item1}{item2}</ul>")
-assert str(element) == "<ul><li>Item 1</li><li>Item 2</li></ul>"
-```
-
-Tag names can also be interpolated:
-
-```python
-tag = "h1"
-element = html(t"<{tag}>Hello, World!</{tag}>")
-assert str(element) == "<h1>Hello, World!</h1>"
-```
-
-Tag name interpolation allows us to support a simple form of "components". For instance, we can define a `Magic()` function that alters both the attributes and children of an element:
-
-```python
-def Magic(attributes: Mapping[str, str | None], children: Sequence[str | Element]) -> Element:
-    """A simple, but extremely magical, component."""
-    magic_attributes = {**attributes, "data-magic": "yes"}
-    magic_children = [*children, "Magic!"]
-    return Element("div", magic_attributes, magic_children)
-
-element = html(t'<{Magic} id="wow"><b>FUN!</b></{Magic}>')
-assert str(element) == '<div id="wow" data-magic="yes"><b>FUN!</b>Magic!</div>'
-```
+This repository _used_ to contain a real working implementation of `html()`, but it was for demonstration purposes only. We have since built a much more [robust HTML templating package, `tdom`](https://github.com/t-strings/tdom), which is based on the same ideas but is much more fully featured. We hope that, in addition to being a useful package in its own right, `tdom` will also serve as a more complete reference implementation of the ideas described in PEP 750.
 
-The `html()` template processing code sees that `{Magic}` is an interpolation, that it occurs in the tag position, and that its value is a `Callable`. As a result, `html()` calls `Magic()` with the interpolated children and attributes and uses the result returned _by_ `Magic()` as the final `Element`.
+(You can find the older HTML templating examples in the commit history, in case you still want to see them.)