backrefs 8.1__tar.gz → 8.2__tar.gz

{backrefs-8.1 → backrefs-8.2}/.pyspelling.yml

@@ -18,11 +18,10 @@ matrix:
       - alt
       ignores:
       - 'code, pre'
-      - 'a:is(.magiclink-compare, .magiclink-commit, .magiclink-repository)'
       - 'span.keys'
       - '.MathJax_Preview, .md-nav__link, .md-footer-custom-text, .md-source__repository, .headerlink, .md-icon'
-      - '.md-social__link, .magiclink-issue'
-  
+      - '.md-social__link, .magiclink'
+
   - pyspelling.filters.url:
 
 - name: markdown

{backrefs-8.1 → backrefs-8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: backrefs
-Version: 8.1
+Version: 8.2
 Summary: A wrapper around re and regex that adds additional back references.
 Project-URL: Homepage, https://github.com/facelessuser/backrefs
 Author-email: Isaac Muse <Isaac.Muse@gmail.com>
@@ -13,7 +13,6 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
@@ -21,7 +20,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Provides-Extra: extras
 Requires-Dist: regex; extra == 'extras'
 Description-Content-Type: text/markdown

{backrefs-8.1 → backrefs-8.2}/backrefs/__meta__.py

@@ -193,5 +193,5 @@ def parse_version(ver: str) -> Version:
     return Version(major, minor, micro, release, pre, post, dev)
 
 
-__version_info__ = Version(8, 1, 0, "final")
+__version_info__ = Version(8, 2, 0, "final")
 __version__ = __version_info__._get_canonical()

{backrefs-8.1 → backrefs-8.2}/backrefs/_bre_parse.py

@@ -10,7 +10,6 @@ import sys
 import copyreg as _copyreg
 from . import util as _util
 from .util import PatternError
-import unicodedata as _unicodedata
 from . import uniprops as _uniprops
 from typing import Generic, AnyStr, Match, Any, Pattern, cast
 
@@ -37,7 +36,7 @@ _WORD = _LETTERS_UNDERSCORE | _DIGIT
 _STANDARD_ESCAPES = frozenset(('a', 'b', 'f', 'n', 'r', 't', 'v'))
 _CURLY_BRACKETS = frozenset(('{', '}'))
 _PROPERTY_STRIP = frozenset((' ', '-', '_'))
-_PROPERTY = _WORD | _DIGIT | _PROPERTY_STRIP
+_PROPERTY = _WORD | _DIGIT | _PROPERTY_STRIP | frozenset(('.',))
 _SCOPED_FLAGS = frozenset(('a', 'i', 'L', 'm', 'u', 's', 'x'))
 _SCOPED_INV_FLAGS = frozenset(('i', 'm', 's', 'x'))
 _SCOPED_END = frozenset((':', ')'))
@@ -176,7 +175,7 @@ class _SearchParser(Generic[AnyStr]):
         value = []
         try:
             c = next(i)
-            if c.upper() in _ASCII_LETTERS:
+            if not brackets and c.upper() in _ASCII_LETTERS:
                 prop.append(c)
             elif (not brackets and c != '{') or (brackets and c != ':'):
                 raise PatternError(f"Unicode property missing '{{' at {i.index - 1}!")
@@ -533,7 +532,7 @@ class _SearchParser(Generic[AnyStr]):
     def unicode_name(self, name: str, in_group: bool = False) -> list[str]:
         """Insert Unicode value by its name."""
 
-        value = ord(_unicodedata.lookup(name))
+        value = ord(_util.unicode_char(name))
         if self.is_bytes and value > 0xFF:
             if not in_group:
                 return ['(?!)']
@@ -755,7 +754,7 @@ class _ReplaceParser(Generic[AnyStr]):
                         else:
                             width.append(fill)
                             fill = None
-                    else:
+                    elif c != '}':
                         fill = c
                         c = self.format_next(i)
                         if fill == 's' and c == '}':
@@ -852,6 +851,18 @@ class _ReplaceParser(Generic[AnyStr]):
 
         return ''.join(value) if value else None
 
+    def append_chars(self, text: str, i: _util.StringIter) -> None:
+        """Append each character of an escape value as a template escape."""
+
+        for c in text:
+            value = ord(c)
+            if self.use_format and value in _CURLY_BRACKETS_ORD:
+                self.handle_format(c, i)
+            elif value <= 0xFF:
+                self.result.append(f'\\{value:03o}')
+            else:
+                self.result.append(c)
+
     def parse_octal(self, text: str, i: _util.StringIter) -> None:
         """Parse octal value."""
 
@@ -863,15 +874,12 @@ class _ReplaceParser(Generic[AnyStr]):
             single = self.get_single_stack()
             if self.span_stack:
                 text = self.convert_case(chr(value), self.span_stack[-1])
-                value = ord(self.convert_case(text, single)) if single is not None else ord(text)
+                text = self.convert_case(text, single) if single is not None else text
             elif single:
-                value = ord(self.convert_case(chr(value), single))
-            if self.use_format and value in _CURLY_BRACKETS_ORD:
-                self.handle_format(chr(value), i)
-            elif value <= 0xFF:
-                self.result.append(f'\\{value:03o}')
+                text = self.convert_case(chr(value), single)
             else:
-                self.result.append(chr(value))
+                text = chr(value)
+            self.append_chars(text, i)
 
     def get_named_unicode(self, i: _util.StringIter) -> str:
         """Get named Unicode."""
@@ -893,19 +901,16 @@ class _ReplaceParser(Generic[AnyStr]):
     def parse_named_unicode(self, i: _util.StringIter) -> None:
         """Parse named Unicode."""
 
-        value = ord(_unicodedata.lookup(self.get_named_unicode(i)))
+        value = ord(_util.unicode_char(self.get_named_unicode(i)))
         single = self.get_single_stack()
         if self.span_stack:
             text = self.convert_case(chr(value), self.span_stack[-1])
-            value = ord(self.convert_case(text, single)) if single is not None else ord(text)
+            text = self.convert_case(text, single) if single is not None else text
         elif single:
-            value = ord(self.convert_case(chr(value), single))
-        if self.use_format and value in _CURLY_BRACKETS_ORD:
-            self.handle_format(chr(value), i)
-        elif value <= 0xFF:
-            self.result.append(f'\\{value:03o}')
+            text = self.convert_case(chr(value), single)
         else:
-            self.result.append(chr(value))
+            text = chr(value)
+        self.append_chars(text, i)
 
     def get_wide_unicode(self, i: _util.StringIter) -> str:
         """Get narrow Unicode."""
@@ -952,15 +957,12 @@ class _ReplaceParser(Generic[AnyStr]):
         single = self.get_single_stack()
         if self.span_stack:
             text = self.convert_case(chr(value), self.span_stack[-1])
-            value = ord(self.convert_case(text, single)) if single is not None else ord(text)
+            text = self.convert_case(text, single) if single is not None else text
         elif single:
-            value = ord(self.convert_case(chr(value), single))
-        if self.use_format and value in _CURLY_BRACKETS_ORD:
-            self.handle_format(chr(value), i)
-        elif value <= 0xFF:
-            self.result.append(f'\\{value:03o}')
+            text = self.convert_case(chr(value), single)
         else:
-            self.result.append(chr(value))
+            text = chr(value)
+        self.append_chars(text, i)
 
     def get_byte(self, i: _util.StringIter) -> str:
         """Get byte."""
@@ -981,13 +983,12 @@ class _ReplaceParser(Generic[AnyStr]):
         single = self.get_single_stack()
         if self.span_stack:
             text = self.convert_case(chr(value), self.span_stack[-1])
-            value = ord(self.convert_case(text, single)) if single is not None else ord(text)
+            text = self.convert_case(text, single) if single is not None else text
         elif single:
-            value = ord(self.convert_case(chr(value), single))
-        if self.use_format and value in _CURLY_BRACKETS_ORD:
-            self.handle_format(chr(value), i)
+            text = self.convert_case(chr(value), single)
         else:
-            self.result.append(f'\\{value:03o}')
+            text = chr(value)
+        self.append_chars(text, i)
 
     def get_named_group(self, t: str, i: _util.StringIter) -> str:
         """Get group number."""
@@ -1004,16 +1005,18 @@ class _ReplaceParser(Generic[AnyStr]):
                 value.append(c)
                 c = next(i)
                 while c != '>':
-                    if c in _DIGIT:
-                        value.append(c)
+                    if c not in _DIGIT:
+                        raise PatternError(f"Bad character in group name at {i.index - 1}!")
+                    value.append(c)
                     c = next(i)
                 value.append(c)
             elif c in _LETTERS_UNDERSCORE:
                 value.append(c)
                 c = next(i)
                 while c != '>':
-                    if c in _WORD:
-                        value.append(c)
+                    if c not in _WORD:
+                        raise PatternError(f"Bad character in group name at {i.index - 1}!")
+                    value.append(c)
                     c = next(i)
                 value.append(c)
             else:
@@ -1062,7 +1065,7 @@ class _ReplaceParser(Generic[AnyStr]):
         elif not self.is_bytes and t == "u":
             value = chr(int(self.get_narrow_unicode(i), 16))
         elif not self.is_bytes and t == "N":
-            value = _unicodedata.lookup(self.get_named_unicode(i))
+            value = _util.unicode_char(self.get_named_unicode(i))
         elif t == "x":
             value = chr(int(self.get_byte(i), 16))
         else:

{backrefs-8.1 → backrefs-8.2}/backrefs/_bregex_parse.py

@@ -5,7 +5,6 @@ Licensed under MIT
 Copyright (c) 2011 - 2020 Isaac Muse <isaacmuse@gmail.com>
 """
 from __future__ import annotations
-import unicodedata as _unicodedata
 import copyreg as _copyreg
 from . import util as _util
 from .util import PatternError
@@ -599,7 +598,7 @@ class _ReplaceParser(Generic[AnyStr]):
                         else:
                             width.append(fill)
                             fill = None
-                    else:
+                    elif c != '}':
                         fill = c
                         c = self.format_next(i)
                         if fill == 's' and c == '}':
@@ -696,6 +695,18 @@ class _ReplaceParser(Generic[AnyStr]):
 
         return ''.join(value) if value else None
 
+    def append_chars(self, text: str, i: _util.StringIter) -> None:
+        """Append each character of an escape value as a template escape."""
+
+        for c in text:
+            value = ord(c)
+            if self.use_format and value in _CURLY_BRACKETS_ORD:
+                self.handle_format(c, i)
+            elif value <= 0xFF:
+                self.result.append(f'\\{value:03o}')
+            else:
+                self.result.append(c)
+
     def parse_octal(self, text: str, i: _util.StringIter) -> None:
         """Parse octal value."""
 
@@ -707,15 +718,12 @@ class _ReplaceParser(Generic[AnyStr]):
             single = self.get_single_stack()
             if self.span_stack:
                 text = self.convert_case(chr(value), self.span_stack[-1])
-                value = ord(self.convert_case(text, single)) if single is not None else ord(text)
+                text = self.convert_case(text, single) if single is not None else text
             elif single:
-                value = ord(self.convert_case(chr(value), single))
-            if self.use_format and value in _CURLY_BRACKETS_ORD:
-                self.handle_format(chr(value), i)
-            elif value <= 0xFF:
-                self.result.append(f'\\{value:03o}')
+                text = self.convert_case(chr(value), single)
             else:
-                self.result.append(chr(value))
+                text = chr(value)
+            self.append_chars(text, i)
 
     def get_named_unicode(self, i: _util.StringIter) -> str:
         """Get named Unicode."""
@@ -737,19 +745,16 @@ class _ReplaceParser(Generic[AnyStr]):
     def parse_named_unicode(self, i: _util.StringIter) -> None:
         """Parse named Unicode."""
 
-        value = ord(_unicodedata.lookup(self.get_named_unicode(i)))
+        value = ord(_util.unicode_char(self.get_named_unicode(i)))
         single = self.get_single_stack()
         if self.span_stack:
             text = self.convert_case(chr(value), self.span_stack[-1])
-            value = ord(self.convert_case(text, single)) if single is not None else ord(text)
+            text = self.convert_case(text, single) if single is not None else text
         elif single:
-            value = ord(self.convert_case(chr(value), single))
-        if self.use_format and value in _CURLY_BRACKETS_ORD:
-            self.handle_format(chr(value), i)
-        elif value <= 0xFF:
-            self.result.append(f'\\{value:03o}')
+            text = self.convert_case(chr(value), single)
         else:
-            self.result.append(chr(value))
+            text = chr(value)
+        self.append_chars(text, i)
 
     def get_wide_unicode(self, i: _util.StringIter) -> str:
         """Get narrow Unicode."""
@@ -796,15 +801,12 @@ class _ReplaceParser(Generic[AnyStr]):
         single = self.get_single_stack()
         if self.span_stack:
             text = self.convert_case(chr(value), self.span_stack[-1])
-            value = ord(self.convert_case(text, single)) if single is not None else ord(text)
+            text = self.convert_case(text, single) if single is not None else text
         elif single:
-            value = ord(self.convert_case(chr(value), single))
-        if self.use_format and value in _CURLY_BRACKETS_ORD:
-            self.handle_format(chr(value), i)
-        elif value <= 0xFF:
-            self.result.append(f'\\{value:03o}')
+            text = self.convert_case(chr(value), single)
         else:
-            self.result.append(chr(value))
+            text = chr(value)
+        self.append_chars(text, i)
 
     def get_byte(self, i: _util.StringIter) -> str:
         """Get byte."""
@@ -825,13 +827,12 @@ class _ReplaceParser(Generic[AnyStr]):
         single = self.get_single_stack()
         if self.span_stack:
             text = self.convert_case(chr(value), self.span_stack[-1])
-            value = ord(self.convert_case(text, single)) if single is not None else ord(text)
+            text = self.convert_case(text, single) if single is not None else text
         elif single:
-            value = ord(self.convert_case(chr(value), single))
-        if self.use_format and value in _CURLY_BRACKETS_ORD:
-            self.handle_format(chr(value), i)
+            text = self.convert_case(chr(value), single)
         else:
-            self.result.append(f'\\{value:03o}')
+            text = chr(value)
+        self.append_chars(text, i)
 
     def get_named_group(self, t: str, i: _util.StringIter) -> str:
         """Get group number."""
@@ -848,16 +849,18 @@ class _ReplaceParser(Generic[AnyStr]):
                 value.append(c)
                 c = next(i)
                 while c != '>':
-                    if c in _DIGIT:
-                        value.append(c)
+                    if c not in _DIGIT:
+                        raise PatternError(f"Bad character in group name at {i.index - 1}!")
+                    value.append(c)
                     c = next(i)
                 value.append(c)
             elif c in _LETTERS_UNDERSCORE:
                 value.append(c)
                 c = next(i)
                 while c != '>':
-                    if c in _WORD:
-                        value.append(c)
+                    if c not in _WORD:
+                        raise PatternError(f"Bad character in group name at {i.index - 1}!")
+                    value.append(c)
                     c = next(i)
                 value.append(c)
             else:
@@ -906,7 +909,7 @@ class _ReplaceParser(Generic[AnyStr]):
         elif not self.is_bytes and t == "u":
             value = chr(int(self.get_narrow_unicode(i), 16))
         elif not self.is_bytes and t == "N":
-            value = _unicodedata.lookup(self.get_named_unicode(i))
+            value = _util.unicode_char(self.get_named_unicode(i))
         elif t == "x":
             value = chr(int(self.get_byte(i), 16))
         else:

{backrefs-8.1 → backrefs-8.2}/backrefs/util.py

@@ -7,6 +7,7 @@ Copyright (c) 2015 - 2020 Isaac Muse <isaacmuse@gmail.com>
 from __future__ import annotations
 import warnings
 import sys
+import unicodedata as _unicodedata
 from typing import Any, Callable, AnyStr
 
 PY311 = (3, 11) <= sys.version_info
@@ -23,6 +24,15 @@ class PatternError(Exception):
     """Pattern error."""
 
 
+def unicode_char(name: str) -> str:
+    """Unicode character by its official name, raising our pattern error when no character has it."""
+
+    try:
+        return _unicodedata.lookup(name)
+    except KeyError as e:
+        raise PatternError(f"Undefined Unicode character name {name!r}!") from e
+
+
 class StringIter:
     """Preprocess replace tokens."""
 

backrefs-8.2/docs/src/dictionary/en-custom.txt

@@ -0,0 +1,67 @@
+API
+Accessors
+Backport
+Backrefs
+Bre
+Bregex
+CVE
+Changelog
+EmojiOne
+Feb
+Formatter
+GitHub
+Gitter
+Jan
+Jun
+MERCHANTABILITY
+Mar
+MkDocs
+NONINFRINGEMENT
+Posix
+PyMdown
+PyPI
+PyPI's
+Regex
+Regex's
+Sep
+Tidelift
+Tox
+Twemoji
+Zensical
+accessor
+backend
+boolean
+decrement
+deprecations
+emoji
+enablement
+formatter
+grapheme
+hashable
+incrementing
+namespaced
+natively
+parsers
+plugin
+posix
+postfix
+pre
+preprocess
+preprocesses
+preprocessing
+preprocessor
+prerelease
+prereleases
+refactored
+reinstalling
+reparsing
+requesters
+sublicense
+subpattern
+subpatterns
+tuple
+uncompiled
+unescaped
+unterminated
+validator
+whitespace

backrefs-8.2/docs/src/dictionary/en-python.txt

@@ -0,0 +1,15 @@
+BOM
+BOMs
+Bre
+Preprocess
+UTF
+backref
+backrefs
+bidi
+bregex
+builtin
+enum
+expander
+regex
+sortable
+whitespace

{backrefs-8.1 → backrefs-8.2}/docs/src/markdown/about/changelog.md

@@ -3,6 +3,23 @@ icon: lucide/scroll-text
 ---
 # Changelog
 
+## 8.2
+
+-   **NEW**: Drop Python 3.10.
+-   **FIX**: Fix error in replace templates when casing a character escape gives two characters (`\C\xdf\E`).
+-   **FIX**: Fix wrong text or errors when case conversion of a `\x` escape exceeds the byte range in replace templates.
+-   **FIX**: Fix an empty format specification (`{1:}`) raising an error in format replace templates.
+-   **FIX**: Fix Unicode properties, such as general category `\p{L}` and `\p{Bidi_Class=L}`, not matching ideographs,
+    Hangul syllables, and other characters Unicode defines as ranges.
+-   **FIX**: Fix `\g<...>` references in replace templates silently dropping invalid characters in a group name
+    instead of raising an error.
+-   **FIX**: Fix `\p{...}` Unicode properties rejecting the canonical dotted value form (e.g. `Age=1.1`),
+    which previously only worked through the alias form (e.g. `V1_1`).
+-   **FIX**: Fix issue where Unicode properties within character classes (e.g. `[x[:property:]]`) were incorrectly
+    detected with `[x[l]]` (@rahul05ranjan).
+-   **FIX**: Fix an undefined Unicode name in `\N{...}` raising a `KeyError` instead of `PatternError`
+    (@rahul05ranjan).
+
 ## 8.1
 
 -   **NEW**: Add official support for Python 3.15.

{backrefs-8.1 → backrefs-8.2}/docs/src/markdown/refs.md

@@ -92,7 +92,7 @@ implementation of Unicode properties. Some properties may not be available on ce
 included Unicode build.
 
 It is important to note that Backrefs handles Unicode properties by transforming them to character classes with all the
-associated characters: `\p{Cs}` --> `[\ud800\udb7f-\udb80\udbff-\udc00\udfff]`.  Because of this, Backrefs can create
+associated characters: `\p{Cs}` --> `[\ud800-\udfff]`.  Because of this, Backrefs can create
 really large regular expressions that the underlying engine must walk through.  In short, Re with Backrefs will never be
 as efficient or fast as using Regex's Unicode properties, but it is very useful when you need or want to use Re.
 

{backrefs-8.1 → backrefs-8.2}/hatch_build.py

@@ -74,7 +74,6 @@ class CustomMetadataHook(MetadataHookInterface):
             'License :: OSI Approved :: MIT License',
             'Operating System :: OS Independent',
             'Programming Language :: Python :: 3',
-            'Programming Language :: Python :: 3.10',
             'Programming Language :: Python :: 3.11',
             'Programming Language :: Python :: 3.12',
             'Programming Language :: Python :: 3.13',

{backrefs-8.1 → backrefs-8.2}/pyproject.toml

@@ -9,7 +9,7 @@ name = "backrefs"
 description = "A wrapper around re and regex that adds additional back references."
 readme = "README.md"
 license = "MIT"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 authors = [
     { name = "Isaac Muse", email = "Isaac.Muse@gmail.com" },
 ]
@@ -39,11 +39,10 @@ include = [
     "/docs/src/markdown/**/*.md",
     "/docs/src/markdown/**/*.gif",
     "/docs/src/markdown/**/*.png",
-    "/docs/src/markdown/dictionary/*.txt",
+    "/docs/src/dictionary/*.txt",
     "/docs/theme/**/*.css",
     "/docs/theme/**/*.js",
     "/docs/theme/**/*.html",
-    "/requirements/*.txt",
     "/backrefs/**/*.py",
     "/backrefs/py.typed",
     "/tests/**/*.py",
@@ -52,7 +51,7 @@ include = [
     "/tools/unicodedata/LICENSE",
     "/.pyspelling.yml",
     "/.coveragerc",
-    "/mkdocs.yml"
+    "/zensical.yml"
 ]
 
 exclude = [
@@ -155,10 +154,10 @@ dependencies = [
 ]
 
 [[tool.hatch.envs.dev.matrix]]
-python = ["3.10", "3.11", "3.12", "3.13", "3.14", "3.15"]
+python = ["3.11", "3.12", "3.13", "3.14", "3.15"]
 
 [[tool.hatch.envs.dev-stdlib.matrix]]
-python = ["3.10", "3.11", "3.12", "3.13", "3.14", "3.15"]
+python = ["3.11", "3.12", "3.13", "3.14", "3.15"]
 
 [tool.hatch.envs.dev.scripts]
 types = """
@@ -196,4 +195,4 @@ build = """
 python tools/unidatadownload.py && \
 python tools/unipropgen.py backrefs/uniprops/unidata && \
 python -m zensical.main build -f zensical.yml --clean
-"""
+"""

{backrefs-8.1 → backrefs-8.2}/tests/test_bidiclass.py

@@ -50,6 +50,13 @@ class TestBidiClass(unittest.TestCase):
             result = uniprops.get_unicode_property('bidiclass', k, mode=uniprops.MODE_ASCII)
             self.assertEqual(result, uniprops.fmt_string(v, True))
 
+    def test_bidiclass_range(self):
+        """Test characters `UnicodeData.txt` defines with a `First` and a `Last` line."""
+
+        for char in ('\uac00', '\u4e16', '\ud55c', '\ud7a3'):
+            result = re.match('[%s]' % uniprops.get_unicode_property('bidiclass', 'l'), char)
+            self.assertTrue(result is not None)
+
     def test_bad_bidiclass(self):
         """Test `Bidi Class` property with bad value."""
 

{backrefs-8.1 → backrefs-8.2}/tests/test_bre.py

@@ -161,6 +161,19 @@ class TestSearchTemplate(unittest.TestCase):
         with pytest.warns(FutureWarning):
             self.assertTrue(bre.compile(r'[[:graph:a]').match('a') is not None)
 
+    def test_bare_letter_after_inner_bracket_is_literal(self):
+        """Test that a letter right after an inner `[` is a literal char, not a property."""
+
+        pattern = bre.compile(r'[x[l]]')
+        self.assertTrue(pattern.match('[]') is not None)
+        self.assertTrue(pattern.match('l]') is not None)
+        self.assertTrue(pattern.match('x]') is not None)
+        self.assertTrue(pattern.match('a]') is None)
+        pattern = bre.compile(r'[}[d]')
+        self.assertTrue(pattern.match('[') is not None)
+        self.assertTrue(pattern.match('d') is not None)
+        self.assertTrue(pattern.match('}') is not None)
+
     def test_unicode_property_failures(self):
         """Test Unicode property."""
 
@@ -200,6 +213,12 @@ class TestSearchTemplate(unittest.TestCase):
         with pytest.raises(PatternError):
             bre.compile(r'\N{A')
 
+        with pytest.raises(PatternError):
+            bre.compile(r'\N{Undefined character}')
+
+        with pytest.raises(PatternError):
+            bre.compile_replace(re.compile(r'(a)'), r'\N{Undefined character}')
+
     def test_word_boundary(self):
         """Test word boundary."""
 
@@ -484,6 +503,31 @@ class TestSearchTemplate(unittest.TestCase):
         pattern2 = bre.compile_search('Test [!-\\~]', re.ASCII)
         self.assertEqual(pattern.pattern, pattern2.pattern)
 
+    def test_age_canonical_value(self):
+        """Test the `UCD` canonical age value form (`1.1`, not just the `V1_1` alias)."""
+
+        pattern = bre.compile_search(r'\p{Age=1.1}')
+        pattern2 = bre.compile_search(r'\p{Age=V1_1}')
+        self.assertEqual(pattern.pattern, pattern2.pattern)
+
+        pattern = bre.compile_search(r'\p{Age:1.1}')
+        pattern2 = bre.compile_search(r'\p{Age:V1_1}')
+        self.assertEqual(pattern.pattern, pattern2.pattern)
+
+    def test_age_canonical_value_in_group(self):
+        """Test the canonical age value form inside a character group."""
+
+        pattern = bre.compile_search(r'[\p{Age=13.0}]')
+        pattern2 = bre.compile_search(r'[\p{Age=V13_0}]')
+        self.assertEqual(pattern.pattern, pattern2.pattern)
+
+    def test_age_canonical_value_negated(self):
+        """Test the canonical age value form with a negated property."""
+
+        pattern = bre.compile_search(r'\p{^Age=1.1}')
+        pattern2 = bre.compile_search(r'\p{^Age=V1_1}')
+        self.assertEqual(pattern.pattern, pattern2.pattern)
+
     def test_not_posix_at_start_group(self):
         """Test a situation that is not a POSIX at the start of a group."""
 
@@ -1857,6 +1901,8 @@ class TestReplaceTemplate(unittest.TestCase):
         self.assertEqual(pattern.subf(r'{1:1^30}', 'Testing'), '11111111111111Te11111111111111')
         self.assertEqual(pattern.subf(r'{1:<30s}', 'Testing'), 'Te                            ')
         self.assertEqual(pattern.subf(r'{1:s}', 'Testing'), 'Te')
+        self.assertEqual(pattern.subf(r'{1:}', 'Testing'), 'Te')
+        self.assertEqual(pattern.subf(r'{1:}-x', 'Testing'), 'Te-x')
         self.assertEqual(pattern.subf(r'{2!r}', 'Testing'), "'st'")
 
         with pytest.raises(PatternError):
@@ -1889,6 +1935,8 @@ class TestReplaceTemplate(unittest.TestCase):
         self.assertEqual(pattern.subf(br'{1:1^30}', b'Testing'), b'11111111111111Te11111111111111')
         self.assertEqual(pattern.subf(br'{1:<30s}', b'Testing'), b'Te                            ')
         self.assertEqual(pattern.subf(br'{1:s}', b'Testing'), b'Te')
+        self.assertEqual(pattern.subf(br'{1:}', b'Testing'), b'Te')
+        self.assertEqual(pattern.subf(br'{1:}-x', b'Testing'), b'Te-x')
         self.assertEqual(pattern.subf(br'{2!r}', b'Testing'), b"b'st'")
 
         with pytest.raises(PatternError):
@@ -1909,6 +1957,40 @@ class TestReplaceTemplate(unittest.TestCase):
         with pytest.raises(PatternError):
             pattern.subf(br'{:030}', b'Testing')
 
+    def test_case_hex_above_byte_range(self):
+        """Test case conversion of hex escapes beyond the byte range."""
+
+        pattern = re.compile('Test')
+        for template, expected in (
+            (r'\c\xb5', '\u039c'),
+            (r'\C\xff\E', '\u0178'),
+            (r'\C\l\xb5\E', '\u03bc'),
+            (r'\C\x5c\E', '\\')
+        ):
+            with self.subTest(template=template):
+                expand = bre.compile_replace(pattern, template)
+                results = expand(pattern.match('Test'))
+                self.assertEqual(expected, results)
+
+    def test_case_escape_multiple_chars(self):
+        """Test case conversion of escapes that give more than one character."""
+
+        pattern = re.compile('Test')
+        for template, expected in (
+            (r'\C\xdf\E', 'SS'),
+            (r'\c\337', 'SS'),
+            (r'\C\N{LATIN SMALL LETTER SHARP S}\E', 'SS'),
+            (r'\C\u00df\E', 'SS'),
+            (r'\L\u0130\E', 'i\u0307'),
+            (r'\C\l\460\E', 'i\u0307'),
+            (r'\C\l\N{LATIN CAPITAL LETTER I WITH DOT ABOVE}\E', 'i\u0307'),
+            (r'\C\l\u0130\E', 'i\u0307')
+        ):
+            with self.subTest(template=template):
+                expand = bre.compile_replace(pattern, template)
+                results = expand(pattern.match('Test'))
+                self.assertEqual(expected, results)
+
     def test_dont_case_special_refs(self):
         """Test that we don't case Unicode and bytes tokens, but case the character."""
 
@@ -1979,6 +2061,27 @@ class TestReplaceTemplate(unittest.TestCase):
 class TestExceptions(unittest.TestCase):
     """Test Exceptions."""
 
+    def test_bad_char_in_numeric_group_name(self):
+        """Test bad character in a numeric group name."""
+
+        p = bre.compile_search(r'(a)(b)')
+        with pytest.raises(PatternError):
+            bre.compile_replace(p, r'Replace \g<1X>')
+
+    def test_bad_char_in_group_name(self):
+        """Test bad character in a named group reference."""
+
+        p = bre.compile_search(r'(?P<word>a)(b)')
+        with pytest.raises(PatternError):
+            bre.compile_replace(p, r'Replace \g<w-ord>')
+
+    def test_bad_char_in_group_name_spacing(self):
+        """Test spacing in a group name reference."""
+
+        p = bre.compile_search(r'(?P<word>a)(b)')
+        with pytest.raises(PatternError):
+            bre.compile_replace(p, r'Replace \g<word >')
+
     def test_bad_flag(self):
         """Test bad flag."""
 

{backrefs-8.1 → backrefs-8.2}/tests/test_bregex.py

@@ -722,6 +722,9 @@ class TestReplaceTemplate(unittest.TestCase):
         with pytest.raises(PatternError):
             bregex.sub('test', r'\N{A', 'test')
 
+        with pytest.raises(PatternError):
+            bregex.sub('test', r'\N{Undefined character}', 'test')
+
     def test_group_failures(self):
         """Test group failures."""
 
@@ -1538,6 +1541,8 @@ class TestReplaceTemplate(unittest.TestCase):
         self.assertEqual(pattern.subf(r'{1:1^30}', 'Testing'), '11111111111111Te11111111111111')
         self.assertEqual(pattern.subf(r'{1:<30s}', 'Testing'), 'Te                            ')
         self.assertEqual(pattern.subf(r'{1:s}', 'Testing'), 'Te')
+        self.assertEqual(pattern.subf(r'{1:}', 'Testing'), 'Te')
+        self.assertEqual(pattern.subf(r'{1:}-x', 'Testing'), 'Te-x')
         self.assertEqual(pattern.subf(r'{2!r}', 'Testing'), "'st'")
 
         with pytest.raises(PatternError):
@@ -1570,6 +1575,8 @@ class TestReplaceTemplate(unittest.TestCase):
         self.assertEqual(pattern.subf(br'{1:1^30}', b'Testing'), b'11111111111111Te11111111111111')
         self.assertEqual(pattern.subf(br'{1:<30s}', b'Testing'), b'Te                            ')
         self.assertEqual(pattern.subf(br'{1:s}', b'Testing'), b'Te')
+        self.assertEqual(pattern.subf(br'{1:}', b'Testing'), b'Te')
+        self.assertEqual(pattern.subf(br'{1:}-x', b'Testing'), b'Te-x')
         self.assertEqual(pattern.subf(br'{2!r}', b'Testing'), b"b'st'")
 
         with pytest.raises(PatternError):
@@ -1590,6 +1597,39 @@ class TestReplaceTemplate(unittest.TestCase):
         with pytest.raises(ValueError):
             pattern.subf(br'{:030}', b'Testing')
 
+    def test_case_hex_above_byte_range(self):
+        """Test case conversion of hex escapes beyond the byte range."""
+
+        pattern = regex.compile('Test')
+        for template, expected in (
+            (r'\c\xb5', '\u039c'),
+            (r'\C\l\xb5\E', '\u03bc'),
+            (r'\C\x5c\E', '\\')
+        ):
+            with self.subTest(template=template):
+                expand = bregex.compile_replace(pattern, template)
+                results = expand(pattern.match('Test'))
+                self.assertEqual(expected, results)
+
+    def test_case_escape_multiple_chars(self):
+        """Test case conversion of escapes that give more than one character."""
+
+        pattern = regex.compile('Test')
+        for template, expected in (
+            (r'\C\xdf\E', 'SS'),
+            (r'\c\337', 'SS'),
+            (r'\C\N{LATIN SMALL LETTER SHARP S}\E', 'SS'),
+            (r'\C\u00df\E', 'SS'),
+            (r'\L\u0130\E', 'i\u0307'),
+            (r'\C\l\460\E', 'i\u0307'),
+            (r'\C\l\N{LATIN CAPITAL LETTER I WITH DOT ABOVE}\E', 'i\u0307'),
+            (r'\C\l\u0130\E', 'i\u0307')
+        ):
+            with self.subTest(template=template):
+                expand = bregex.compile_replace(pattern, template)
+                results = expand(pattern.match('Test'))
+                self.assertEqual(expected, results)
+
     def test_dont_case_special_refs(self):
         """Test that we don't case Unicode and bytes tokens, but case the character."""
 
@@ -1660,6 +1700,27 @@ class TestReplaceTemplate(unittest.TestCase):
 class TestExceptions(unittest.TestCase):
     """Test Exceptions."""
 
+    def test_bad_char_in_numeric_group_name(self):
+        """Test bad character in a numeric group name."""
+
+        p = bregex.compile_search(r'(a)(b)')
+        with pytest.raises(PatternError):
+            bregex.compile_replace(p, r'Replace \g<1X>')
+
+    def test_bad_char_in_group_name(self):
+        """Test bad character in a named group reference."""
+
+        p = bregex.compile_search(r'(?P<word>a)(b)')
+        with pytest.raises(PatternError):
+            bregex.compile_replace(p, r'Replace \g<w-ord>')
+
+    def test_bad_char_in_group_name_spacing(self):
+        """Test spacing in a group name reference."""
+
+        p = bregex.compile_search(r'(?P<word>a)(b)')
+        with pytest.raises(PatternError):
+            bregex.compile_replace(p, r'Replace \g<word >')
+
     def test_format_existing_group_no_match_with_index(self):
         """Test format group with no match and attempt at indexing."""
 

{backrefs-8.1 → backrefs-8.2}/tests/test_generalcategory.py

@@ -125,6 +125,14 @@ class TestGeneralCategory(unittest.TestCase):
                 result = uniprops.get_unicode_property(category, mode=uniprops.MODE_ASCII)
                 self.assertEqual(result, uniprops.fmt_string(v2, True))
 
+    def test_gc_range(self):
+        """Test characters `UnicodeData.txt` defines with a `First` and a `Last` line."""
+
+        for char in ('\uac00', '\u4e16', '\ud55c', '\ud7a3'):
+            for category, match in (('lo', True), ('l', True), ('cn', False), ('^cn', True)):
+                result = re.match('[%s]' % uniprops.get_unicode_property(category), char)
+                self.assertEqual(result is not None, match)
+
     def test_bad_single_subcategory(self):
         """Test `Joining Group` property with bad value."""
 

{backrefs-8.1 → backrefs-8.2}/tools/unipropgen.py

@@ -60,6 +60,22 @@ def create_span(unirange, is_bytes=False):
     return list(range(unirange[0], unirange[1] + 1))
 
 
+def expand_ranges(lines):
+    """Give each code point in a `First`/`Last` range of `UnicodeData.txt` a line of its own."""
+
+    first = None
+    for line in lines:
+        code, name, fields = line.split(';', 2)
+        if name.endswith(', First>'):
+            first = int(code, 16)
+        elif first is None:
+            yield line
+        else:
+            for i in range(first, int(code, 16) + 1):
+                yield '%04X;%s;%s' % (i, name, fields)
+            first = None
+
+
 def not_explicitly_defined(table, name, is_bytes=False):
     """Compose a table with the specified entry name of values not explicitly defined."""
 
@@ -780,7 +796,7 @@ def gen_bidi(output, ascii_props=False, append=False, prefix="", aliases=None):
 
     max_range = MAXVALIDASCII if ascii_props else MAXUNICODE
     with open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'UnicodeData.txt'), 'r', encoding='utf-8') as uf:
-        for line in uf:
+        for line in expand_ranges(uf):
             data = line.strip().split(';')
             if data:
                 bidi = data[4].strip().lower()
@@ -1042,7 +1058,7 @@ def gen_properties(output, files, aliases, ascii_props=False, append=False):
     table = {'l': {'c': []}}
     itable = {'l': {}}
     with open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'UnicodeData.txt'), 'r', encoding='utf-8') as uf:
-        for line in uf:
+        for line in expand_ranges(uf):
             data = line.strip().split(';')
             if data:
                 i = int(data[0], 16)

backrefs-8.2/zensical.yml

@@ -0,0 +1,178 @@
+site_name: Backrefs Documentation
+site_url: https://facelessuser.github.io/backrefs
+repo_url: https://github.com/facelessuser/backrefs
+edit_uri: tree/master/docs/src/markdown
+site_description: A library to add additional back references to regular expressions.
+copyright: |
+  Copyright &copy; 2015 - 2026 <a href="https://github.com/facelessuser"  target="_blank" rel="noopener">Isaac Muse</a>
+
+docs_dir: docs/src/markdown
+theme:
+  name: zensical_pymdownx
+  custom_dir: docs/theme
+  features:
+    - announce.dismiss
+    - navigation.tabs
+    - navigation.top
+    - navigation.instant
+    - navigation.indexes
+    - navigation.path
+    - navigation.footer
+    - toc.follow
+    - content.tabs.link
+    - search.share
+    - search.highlight
+    - search.suggest
+    - content.code.copy
+    - content.tabs.link
+    - content.code.annotations
+
+nav:
+  - Getting Started:
+    - Installation: index.md
+    - Usage: usage.md
+    - Supported References: refs.md
+  - About:
+    - Contributing &amp; Support: about/contributing.md
+    - Security Vulnerabilities: about/security.md
+    - Changelog: about/changelog.md
+    - License: about/license.md
+
+markdown_extensions:
+  - markdown.extensions.toc:
+      slugify: !!python/object/apply:pymdownx.slugs.slugify {kwds: {case: lower}}
+      permalink: ""
+  - markdown.extensions.smarty:
+      smart_quotes: false
+  - pymdownx.betterem:
+  - markdown.extensions.attr_list:
+  - markdown.extensions.tables:
+  - markdown.extensions.abbr:
+  - markdown.extensions.md_in_html:
+  - pymdownx.superfences:
+      custom_fences:
+        - name: py
+          class: 'highlight'
+          format: !!python/object/apply:tools.pycon.py_command_formatter
+            kwds:
+              init: |
+                import backrefs
+                from backrefs import bre, bregex
+                import re
+                import regex
+          validator: !!python/name:tools.pycon.py_command_validator
+          reset: !!python/name:tools.pycon.py_command_reset
+        - name: python
+          class: 'highlight'
+          format: !!python/object/apply:tools.pycon.py_command_formatter
+            kwds:
+              init: |
+                import backrefs
+                from backrefs import bre, bregex
+                import re
+                import regex
+          validator: !!python/name:tools.pycon.py_command_validator
+          reset: !!python/name:tools.pycon.py_command_reset
+  - pymdownx.highlight:
+      line_spans: __codeline
+      line_anchors: __codelineno
+      anchor_linenums: True
+      extend_pygments_lang:
+        - name: php-inline
+          lang: php
+          options:
+            startinline: true
+        - name: pycon3
+          lang: pycon
+          options:
+            python3: true
+  - pymdownx.inlinehilite:
+  - pymdownx.magiclink:
+      repo_url_shortener: true
+      repo_url_shorthand: true
+      social_url_shorthand: true
+      user: facelessuser
+      repo: backrefs
+  - pymdownx.tilde:
+  - pymdownx.caret:
+  - pymdownx.smartsymbols:
+  - pymdownx.emoji:
+      emoji_index: !!python/name:material.extensions.emoji.twemoji
+      emoji_generator: !!python/name:material.extensions.emoji.to_svg
+  - pymdownx.escapeall:
+      hardbreak: True
+      nbsp: True
+  - pymdownx.tasklist:
+      custom_checkbox: true
+  - pymdownx.progressbar:
+  - pymdownx.mark:
+  - pymdownx.striphtml:
+  - pymdownx.snippets:
+      base_path:
+      - docs/src/markdown/.snippets
+      - LICENSE.md
+      - SECURITY.md
+      auto_append:
+      - links.md
+  - pymdownx.keys:
+      separator: "\uff0b"
+  - pymdownx.saneheaders:
+  - pymdownx.blocks.admonition:
+      types:
+      - new
+      - settings
+      - note
+      - abstract
+      - info
+      - tip
+      - success
+      - question
+      - warning
+      - failure
+      - danger
+      - bug
+      - example
+      - quote
+  - pymdownx.blocks.details:
+      types:
+      - name: details-new
+        class: new
+      - name: details-settings
+        class: settings
+      - name: details-note
+        class: note
+      - name: details-abstract
+        class: abstract
+      - name: details-info
+        class: info
+      - name: details-tip
+        class: tip
+      - name: details-success
+        class: success
+      - name: details-question
+        class: question
+      - name: details-warning
+        class: warning
+      - name: details-failure
+        class: failure
+      - name: details-danger
+        class: danger
+      - name: details-bug
+        class: bug
+      - name: details-example
+        class: example
+      - name: details-quote
+        class: quote
+  - pymdownx.blocks.html:
+  - pymdownx.blocks.definition:
+  - pymdownx.blocks.tab:
+      alternate_style: True
+  - pymdownx.quotes:
+      callouts: true
+
+extra:
+  social:
+    - icon: fontawesome/brands/github
+      link: https://github.com/facelessuser
+  zensical_pymdownx:
+    sponsor: https://github.com/sponsors/facelessuser