Add support for Python 3.14 (#206)

facelessuser · web-flow · commit 9c90c767366d · 2025-08-27T09:23:05.000-06:00
* Add support for Python 3.14

* Add support for Python 3.14 t-strings and resolve codec deprecations
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
@@ -17,7 +17,7 @@ jobs:
       max-parallel: 5
       matrix:
         platform: [ubuntu-latest] #, windows-latest]
-        python-version: [3.9, '3.10', 3.11, 3.12, 3.13]
+        python-version: [3.9, '3.10', 3.11, 3.12, 3.13, 3.14]
         include:
           - python-version: 3.9
             continue-on-error: false
@@ -29,6 +29,8 @@ jobs:
             continue-on-error: false
           - python-version: 3.13
             continue-on-error: false
+          - python-version: 3.14
+            continue-on-error: false
         # exclude:
         #   - platform: windows-latest
         #     python-version: 3.9
diff --git a/docs/src/markdown/about/changelog.md b/docs/src/markdown/about/changelog.md
@@ -6,6 +6,8 @@
     dictionary already exists. Changes to a custom dictionary will be ignored.
 -   **NEW**: Drop support for Python 3.8.
 -   **NEW**: Add official support for Python 3.13.
+-   **NEW**: Add official support for Python 3.14.
+-   **NEW**: Python filter is now aware of Python 3.14+ t-strings.
 
 ## 2.10
 
diff --git a/docs/src/markdown/filters/python.md b/docs/src/markdown/filters/python.md
@@ -46,11 +46,15 @@ types are `b` for bytes, `f` for format, `u` for Unicode, and `r` for raw.  `f`
 form `#!py3 "my string {}".format(value)"`, and though f-strings are Unicode, they are treated as a separate string type
 from Unicode. Case is not important, and the default value is `fu`.
 
-If specifying `r`, you must also specify either `u`, `b`, or `f` as raw strings are also either `u`, `b`, or `f`
-strings. Selecting `ur` will select both Unicode strings and Unicode raw strings. If you need to target just raw
+If specifying `r`, you must also specify either `u`, `b`, `f`, or `t` as raw strings are also either `u`, `b`, `f`, or
+`t` strings. Selecting `ur` will select both Unicode strings and Unicode raw strings. If you need to target just raw
 strings, you can use `r*` which will target all raw strings types: raw Unicode, raw format, and raw bytes. You can use
 `*` for other types as well. You can also just specify `*` by itself to target all string types.
 
+/// new | New in 2.11
+Template string support was added in 2.11 and is only available for Python 3.14+.
+///
+
 ## Options
 
 Options          | Type     | Default       | Description
@@ -60,7 +64,7 @@ Options          | Type     | Default       | Description
 `group_comments` | bool     | `#!py3 False` | Group consecutive Python comments as one `SourceText` entry.
 `decode_escapes` | bool     | `#!py3 True`  | Decode escapes and strip out format variables. Behavior is based on the string type that is encountered. This affects both docstrings and non-docstrings.
 `strings`        | string   | `#!py3 False` | Return `SourceText` entries for each string (non-docstring).
-`string_types`   | string   | `#!py3 fu`    | Specifies which string types `strings` searches: bytes (`b`), format (`f`), raw (`r`), and Unicode (`u`).  `*` captures all strings, or when used with a type, captures all variants of that type `r*`. This does not affect docstrings. When `docstrings` is enabled, all docstrings are parsed.
+`string_types`   | string   | `#!py3 'ftu'` | Specifies which string types `strings` searches: bytes (`b`), format (`f`), template (`t`), raw (`r`), and Unicode (`u`).  `*` captures all strings, or when used with a type, captures all variants of that type `r*`. This does not affect docstrings. When `docstrings` is enabled, all docstrings are parsed.
 
 ## Categories
 
diff --git a/hatch_build.py b/hatch_build.py
@@ -34,6 +34,7 @@ def update(self, metadata):
             'Programming Language :: Python :: 3.11',
             'Programming Language :: Python :: 3.12',
             'Programming Language :: Python :: 3.13',
+            'Programming Language :: Python :: 3.14',
             'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
             'Topic :: Software Development :: Libraries :: Python Modules'
         ]
diff --git a/pyproject.toml b/pyproject.toml
@@ -121,7 +121,7 @@ legacy_tox_ini = """
 [tox]
 isolated_build = true
 envlist =
-    py39,py310,py311,py312,py313,lint
+    py39,py310,py311,py312,py313,py314,lint
 
 [testenv]
 passenv = LANG,TOX_SPELL_PATH,TOX_SPELL_REQUIRE,HOME
diff --git a/pyspelling/filters/__init__.py b/pyspelling/filters/__init__.py
@@ -238,7 +238,7 @@ def header_check(self, content):
     def filter(self, source_file, encoding):  # noqa A001
         """Open and filter the file from disk."""
 
-        with codecs.open(source_file, 'r', encoding=encoding) as f:
+        with open(source_file, 'r', encoding=encoding, errors='strict') as f:
             text = f.read()
         return [SourceText(text, source_file, encoding, 'text')]
 
diff --git a/pyspelling/filters/context.py b/pyspelling/filters/context.py
@@ -1,7 +1,6 @@
 """Text parser."""
 from .. import filters
 from .. import util
-import codecs
 import re
 from collections import OrderedDict
 
@@ -77,7 +76,7 @@ def setup(self):
     def filter(self, source_file, encoding):  # noqa A001
         """Parse file."""
 
-        with codecs.open(source_file, 'r', encoding=encoding) as f:
+        with open(source_file, 'r', encoding=encoding, errors='strict') as f:
             text = f.read()
 
         return [filters.SourceText(self._filter(text), source_file, encoding, 'context')]
diff --git a/pyspelling/filters/cpp.py b/pyspelling/filters/cpp.py
@@ -445,7 +445,7 @@ def _filter(self, text, context, encoding):
     def filter(self, source_file, encoding):  # noqa A001
         """Parse CPP file."""
 
-        with codecs.open(source_file, 'r', encoding=encoding) as f:
+        with open(source_file, 'r', encoding=encoding, errors='strict') as f:
             text = f.read()
 
         return self._filter(text, source_file, encoding)
diff --git a/pyspelling/filters/javascript.py b/pyspelling/filters/javascript.py
@@ -1,7 +1,6 @@
 """JavaScript filter."""
 import re
 import textwrap
-import codecs
 from .. import filters
 
 RE_JSDOC = re.compile(r"(?s)^/\*\*$(.*?)[ \t]*\*/", re.MULTILINE)
@@ -282,7 +281,7 @@ def _filter(self, text, context, encoding):
     def filter(self, source_file, encoding):  # noqa A001
         """Parse JavaScript file."""
 
-        with codecs.open(source_file, 'r', encoding=encoding) as f:
+        with open(source_file, 'r', encoding=encoding, errors='strict') as f:
             text = f.read()
 
         return self._filter(text, source_file, encoding)
diff --git a/pyspelling/filters/markdown.py b/pyspelling/filters/markdown.py
@@ -1,6 +1,5 @@
 """Markdown filter."""
 from .. import filters
-import codecs
 import markdown
 
 
@@ -37,7 +36,7 @@ def setup(self):
     def filter(self, source_file, encoding):  # noqa A001
         """Parse Markdown file."""
 
-        with codecs.open(source_file, 'r', encoding=encoding) as f:
+        with open(source_file, 'r', encoding=encoding, errors='strict') as f:
             text = f.read()
         return [filters.SourceText(self._filter(text), source_file, encoding, 'markdown')]
 
diff --git a/pyspelling/filters/python.py b/pyspelling/filters/python.py
@@ -7,12 +7,12 @@
 import re
 import textwrap
 import tokenize
-import codecs
 import io
 import unicodedata
 import sys
 
 FSTR_TOKENIZE = (3, 12) <= sys.version_info
+TSTR_TOKENIZE = (3, 14) <= sys.version_info
 
 tokenizer = tokenize.generate_tokens
 PREV_DOC_TOKENS = (tokenize.INDENT, tokenize.DEDENT, tokenize.NEWLINE, tokenize.ENCODING)
@@ -70,20 +70,25 @@
     '''
 )
 
-RE_STRING_TYPE = re.compile(r'''((?:r|u|f|b)+)?(\'''|"""|'|")(.*?)\2''', re.I | re.S)
-
 RE_NON_PRINTABLE = re.compile(r'[\x00-\x09\x0b-\x1f\x7f-\xff]+')
 
-RE_VALID_STRING_TYPES = re.compile(r'^(?:\*|(?:[rubf]\*?)+)$', re.I)
+RE_STRING_TYPE = re.compile(r'''((?:r|u|f|b|t)+)?(\'''|"""|'|")(.*?)\2''', re.I | re.S)
+
+RE_VALID_STRING_TYPES = re.compile(r'^(?:\*|(?:[rubft]\*?)+)$', re.I)
 
-RE_ITER_STRING_TYPES = re.compile(r'(\*|[rubf]\*?)', re.I)
+RE_ITER_STRING_TYPES = re.compile(r'(\*|[rubft]\*?)', re.I)
 
 FMT_STR = (
     'f', 'F',
     'fr', 'rf',
     'Fr', 'rF',
     'fR', 'Rf',
-    'FR', 'RF'
+    'FR', 'RF',
+    't', 'T',
+    'tr', 'rt',
+    'Tr', 'rT',
+    'tR', 'Rt',
+    'TR', 'TF'
 )
 
 
@@ -107,7 +112,7 @@ def get_default_config(self):
             'docstrings': True,
             'strings': False,
             'group_comments': False,
-            'string_types': 'fu',
+            'string_types': 'ftu',
             'decode_escapes': True
         }
 
@@ -157,12 +162,13 @@ def eval_string_type(self, text, is_string=False):
                 wstype.add('f')
                 wstype.add('r')
                 wstype.add('b')
+                wstype.add('t')
             elif value.endswith('*'):
                 wstype.add(value[0].lower())
             else:
                 stype.add(value.lower())
 
-        if is_string and 'b' not in stype and 'f' not in stype:
+        if is_string and 'b' not in stype and 'f' not in stype and 't' not in stype:
             stype.add('u')
 
         return stype, wstype
@@ -232,14 +238,15 @@ def process_strings(self, string, docstrings=False):
         is_bytes = 'b' in stype
         is_raw = 'r' in stype
         is_format = 'f' in stype
+        is_template = 't' in stype
         content = m.group(3)
         if is_raw and (not is_format or not self.decode_escapes):
             string = self.norm_nl(content)
         elif is_raw and is_format:
             string = self.norm_nl(FE_RFESC.sub(self.replace_unicode, content))
         elif is_bytes:
             string = self.norm_nl(RE_BESC.sub(self.replace_bytes, content))
-        elif is_format:
+        elif is_format or is_template:
             string = self.norm_nl(RE_FESC.sub(self.replace_unicode, content))
         else:
             string = self.norm_nl(RE_ESC.sub(self.replace_unicode, content))
@@ -293,11 +300,17 @@ def _filter(self, text, context, encoding):
                     elif name == 'def':
                         stack.append((f'{prefix}{value}()', len(indent), self.FUNCTION))
                     name = None
-            elif FSTR_TOKENIZE and token_type == tokenize.FSTRING_START:
+            elif (
+                (FSTR_TOKENIZE and token_type == tokenize.FSTRING_START) or
+                (TSTR_TOKENIZE and token_type == tokenize.TSTRING_START)
+            ):
                 dstr = not self.catch_same_level(stack, len(indent)) and (prev_token_type in PREV_DOC_TOKENS)
                 stype = self.get_string_type(value)
                 fstring_stack.append((value, dstr) if self.match_string(stype) else ('', dstr))
-            elif FSTR_TOKENIZE and token_type == tokenize.FSTRING_END:
+            elif (
+                (FSTR_TOKENIZE and token_type == tokenize.FSTRING_END) or
+                (TSTR_TOKENIZE and token_type == tokenize.TSTRING_END)
+            ):
                 fstring_stack.pop()
 
             if token_type == tokenize.COMMENT and self.comments:
@@ -317,7 +330,13 @@ def _filter(self, text, context, encoding):
                         loc = f"{stack[0][0]}({line})"
                     comments.append([value[1:], loc, line_num])
 
-            if FSTR_TOKENIZE and token_type == tokenize.FSTRING_MIDDLE and fstring_stack[-1][0]:
+            if (
+                (
+                    (FSTR_TOKENIZE and token_type == tokenize.FSTRING_MIDDLE) or
+                    (TSTR_TOKENIZE and token_type == tokenize.TSTRING_MIDDLE)
+                ) and
+                fstring_stack[-1][0]
+            ):
                 fstr, dstr = fstring_stack[-1]
                 if (self.docstrings and dstr) or (self.strings and not dstr):
                     end = fstr[-1] * (len(fstr) - 1)
@@ -377,7 +396,7 @@ def _filter(self, text, context, encoding):
     def filter(self, source_file, encoding):  # noqa A001
         """Parse Python file returning content."""
 
-        with codecs.open(source_file, 'r', encoding=encoding) as f:
+        with open(source_file, 'r', encoding=encoding, errors='strict') as f:
             return self._filter(f.read(), source_file, encoding)
 
     def sfilter(self, source):
diff --git a/pyspelling/filters/stylesheets.py b/pyspelling/filters/stylesheets.py
@@ -1,6 +1,5 @@
 """Stylesheets filter."""
 import re
-import codecs
 import textwrap
 from .. import filters
 
@@ -165,7 +164,7 @@ def _filter(self, text, context, encoding):
     def filter(self, source_file, encoding):  # noqa A001
         """Parse stylesheet file."""
 
-        with codecs.open(source_file, 'r', encoding=encoding) as f:
+        with open(source_file, 'r', encoding=encoding, errors='strict') as f:
             text = f.read()
 
         return self._filter(text, source_file, encoding)
diff --git a/pyspelling/filters/text.py b/pyspelling/filters/text.py
@@ -65,7 +65,7 @@ def convert(self, text, encoding):
     def filter(self, source_file, encoding):  # noqa A001
         """Open and filter the file from disk."""
 
-        with codecs.open(source_file, 'r', encoding=encoding) as f:
+        with codecs.open(source_file, 'r', encoding=encoding, errors='strict') as f:
             text = f.read()
 
         text, encoding = self.convert(text, encoding)
diff --git a/pyspelling/filters/url.py b/pyspelling/filters/url.py
@@ -1,6 +1,5 @@
 """URL filter."""
 from .. import filters
-import codecs
 import re
 
 # Bare link/email detection
@@ -63,7 +62,7 @@ def _filter(self, text):
     def filter(self, source_file, encoding):  # noqa A001
         """Open and filter the file from disk."""
 
-        with codecs.open(source_file, 'r', encoding=encoding) as f:
+        with open(source_file, 'r', encoding=encoding, errors='strict') as f:
             text = f.read()
 
         return [filters.SourceText(self._filter(text), source_file, encoding, 'url-free')]
diff --git a/pyspelling/util/__init__.py b/pyspelling/util/__init__.py
@@ -3,7 +3,6 @@
 import os
 import sys
 import yaml
-import codecs
 import string
 import random
 import re
@@ -176,7 +175,7 @@ def read_config(file_name):
                 warn_deprecated(
                     "Using '.spelling.yml' as the default is deprecated. Default config is now '.pyspelling.yml'"
                 )
-            with codecs.open(name, 'r', encoding='utf-8') as f:
+            with open(name, 'r', encoding='utf-8', errors='strict') as f:
                 config = yaml_load(f.read())
             break
     # If configuration is still None, or we happened to get an object other than a dictionary (such as a list),
diff --git a/tests/filters/test_python.py b/tests/filters/test_python.py
@@ -1,6 +1,7 @@
 """Test Python plugin."""
 from .. import util
-
+import pytest
+import sys
 
 class TestPython(util.PluginTestCase):
     """Test Python plugin."""
@@ -115,7 +116,7 @@ def setup_fs(self):
               pipeline:
               - pyspelling.filters.python:
                   strings: true
-                  string_types: bfru
+                  string_types: bfrut
                   group_comments: true
             """
         ).format(self.tempdir)
@@ -225,6 +226,33 @@ def function():
         self.mktemp('test.txt', template, 'utf-8')
         self.assert_spellcheck('.pystrings.yml', bad_words)
 
+    @pytest.mark.skipif(sys.version_info < (3, 14), reason="requires python3.14 or higher")
+    def test_python_template(self):
+        """Test Python template strings."""
+
+        template = self.dedent(
+            r'''
+            from string.templatelib import Template, Interpolation
+
+            def lower_upper(template: Template) -> str:
+                """Render static parts lower cased and interpolations upper cased."""
+
+                parts: list[str] = []
+                for item in template:
+                    if isinstance(item, Interpolation):
+                        parts.append(str(item.value).upper())
+                    else:
+                        parts.append(item.lower())
+                return "".join(parts)
+
+            name = "world"
+            print(lower_upper(t"HLLO {name}"))
+            '''
+        )
+
+        self.mktemp('test.txt', template, 'utf-8')
+        self.assert_spellcheck('.pystrings.yml', ['HLLO'])
+
     def test_python_raw_format(self):
         """Test Python raw format strings."""
 

Original file line number	Diff line number	Diff line change
`@@ -34,6 +34,7 @@ def update(self, metadata):`
`34`	`34`	`'Programming Language :: Python :: 3.11',`
`35`	`35`	`'Programming Language :: Python :: 3.12',`
`36`	`36`	`'Programming Language :: Python :: 3.13',`
	`37`	`+ 'Programming Language :: Python :: 3.14',`
`37`	`38`	`'Topic :: Internet :: WWW/HTTP :: Dynamic Content',`
`38`	`39`	`'Topic :: Software Development :: Libraries :: Python Modules'`
`39`	`40`	`]`