backrefs 5.7.post1__tar.gz → 5.8__tar.gz

{backrefs-5.7.post1 → backrefs-5.8}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: backrefs
-Version: 5.7.post1
+Version: 5.8
 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.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -21,7 +20,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Provides-Extra: extras
 Requires-Dist: regex; extra == 'extras'
 Description-Content-Type: text/markdown

{backrefs-5.7.post1 → backrefs-5.8}/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(5, 7, 0, "final", post=1)
+__version_info__ = Version(5, 8, 0, "final")
 __version__ = __version_info__._get_canonical()

{backrefs-5.7.post1 → backrefs-5.8}/backrefs/_bre_parse.py

@@ -204,7 +204,7 @@ class _SearchParser(Generic[AnyStr]):
             c = next(i)
             if c.upper() in _ASCII_LETTERS:
                 prop.append(c)
-            elif not brackets and c != '{' or brackets and c != ':':
+            elif (not brackets and c != '{') or (brackets and c != ':'):
                 raise SyntaxError(f"Unicode property missing '{{' at {i.index - 1}!")
             else:
                 c = next(i)

backrefs-5.8/backrefs/_bregex_typing.py

@@ -0,0 +1,6 @@
+"""Typing objects for the Regex library."""
+import regex  # type: ignore[import]
+from typing import _alias  # type: ignore[attr-defined]
+
+Pattern = _alias(type(regex.compile('')), 1)
+Match = _alias(type(regex.compile('').match('')), 1)

{backrefs-5.7.post1 → backrefs-5.8}/backrefs/bre.py

@@ -481,24 +481,22 @@ def match(
     pattern: AnyStr | Pattern[AnyStr] | Bre[AnyStr],
     string: AnyStr,
     flags: int | _re.RegexFlag = 0,
-    *args: Any,
     **kwargs: Any
 ) -> Match[AnyStr] | None:
     """Apply `match` after applying backrefs."""
 
-    return _re.match(_apply_search_backrefs(pattern, flags), string, flags, *args, **kwargs)
+    return _re.match(_apply_search_backrefs(pattern, flags), string, flags=flags, **kwargs)
 
 
 def fullmatch(
     pattern: AnyStr | Pattern[AnyStr] | Bre[AnyStr],
     string: AnyStr,
     flags: int | _re.RegexFlag = 0,
-    *args: Any,
     **kwargs: Any
 ) -> Match[AnyStr] | None:
     """Apply `fullmatch` after applying backrefs."""
 
-    return _re.fullmatch(_apply_search_backrefs(pattern, flags), string, flags, *args, **kwargs)
+    return _re.fullmatch(_apply_search_backrefs(pattern, flags), string, flags=flags, **kwargs)
 
 
 def split(
@@ -506,36 +504,39 @@ def split(
     string: AnyStr,
     maxsplit: int = 0,
     flags: int | _re.RegexFlag = 0,
-    *args: Any,
     **kwargs: Any
 ) -> list[AnyStr]:
     """Apply `split` after applying backrefs."""
 
-    return _re.split(_apply_search_backrefs(pattern, flags), string, maxsplit, flags, *args, **kwargs)
+    return _re.split(
+        _apply_search_backrefs(pattern, flags),
+        string,
+        maxsplit=maxsplit,
+        flags=flags,
+        **kwargs
+    )
 
 
 def findall(
     pattern: AnyStr | Pattern[AnyStr] | Bre[AnyStr],
     string: AnyStr,
     flags: int | _re.RegexFlag = 0,
-    *args: Any,
     **kwargs: Any
 ) -> list[AnyStr] | list[tuple[AnyStr, ...]]:
     """Apply `findall` after applying backrefs."""
 
-    return _re.findall(_apply_search_backrefs(pattern, flags), string, flags, *args, **kwargs)
+    return _re.findall(_apply_search_backrefs(pattern, flags), string, flags=flags, **kwargs)
 
 
 def finditer(
     pattern: AnyStr | Pattern[AnyStr] | Bre[AnyStr],
     string: AnyStr,
     flags: int | _re.RegexFlag = 0,
-    *args: Any,
     **kwargs: Any
 ) -> Iterator[Match[AnyStr]]:
     """Apply `finditer` after applying backrefs."""
 
-    return _re.finditer(_apply_search_backrefs(pattern, flags), string, flags, *args, **kwargs)
+    return _re.finditer(_apply_search_backrefs(pattern, flags), string, flags=flags, **kwargs)
 
 
 def sub(
@@ -544,7 +545,6 @@ def sub(
     string: AnyStr,
     count: int = 0,
     flags: int | _re.RegexFlag = 0,
-    *args: Any,
     **kwargs: Any
 ) -> AnyStr:
     """Apply `sub` after applying backrefs."""
@@ -559,9 +559,8 @@ def sub(
         pattern,
         (compile_replace(pattern, repl) if is_replace or is_string else repl),
         string,
-        count,
-        0,
-        *args,
+        count=count,
+        flags=0,
         **kwargs
     )
 
@@ -572,7 +571,6 @@ def subf(
     string: AnyStr,
     count: int = 0,
     flags: int | _re.RegexFlag = 0,
-    *args: Any,
     **kwargs: Any
 ) -> AnyStr:
     """Apply `sub` with format style replace."""
@@ -588,9 +586,8 @@ def subf(
         pattern,
         (compile_replace(pattern, repl, flags=rflags) if is_replace or is_string else repl),
         string,
-        count,
-        0,
-        *args,
+        count=count,
+        flags=0,
         **kwargs
     )
 
@@ -601,7 +598,6 @@ def subn(
     string: AnyStr,
     count: int = 0,
     flags: int | _re.RegexFlag = 0,
-    *args: Any,
     **kwargs: Any
 ) -> tuple[AnyStr, int]:
     """Apply `subn` with format style replace."""
@@ -616,9 +612,8 @@ def subn(
         pattern,
         (compile_replace(pattern, repl) if is_replace or is_string else repl),
         string,
-        count,
-        0,
-        *args,
+        count=count,
+        flags=0,
         **kwargs
     )
 
@@ -629,7 +624,6 @@ def subfn(
     string: AnyStr,
     count: int = 0,
     flags: int | _re.RegexFlag = 0,
-    *args: Any,
     **kwargs: Any
 ) -> tuple[AnyStr, int]:
     """Apply `subn` after applying backrefs."""
@@ -645,9 +639,8 @@ def subfn(
         pattern,
         (compile_replace(pattern, repl, flags=rflags) if is_replace or is_string else repl),
         string,
-        count,
-        0,
-        *args,
+        count=count,
+        flags=0,
         **kwargs
     )
 

{backrefs-5.7.post1 → backrefs-5.8}/docs/src/markdown/about/changelog.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 5.8
+
+-   **NEW**: Drop Python 3.8.
+-   **FIX**: Deprecation warnings.
+
 ## 5.7
 
 -   **NEW**: Add support for Python 3.13 beta.
@@ -46,9 +51,9 @@
 -   **FIX**: Match Re and Regex handling when doing a non-format replacement that references a group that is present in
     the search pattern but has no actual captures. Such a case should not fail, but simply return an empty string for
     the group.
--   **FIX**: Format replacements that that have groups with no captures will yield an empty string as the only capture
-    as long as the user does not try to index into any captures as there are no actual captures. This behavior was a bug
-    in Regex that we duplicated and should now be fixed in the latest Regex (mrabarnett/mrab-regex#439) as well as in
+-   **FIX**: Format replacements that have groups with no captures will yield an empty string as the only capture as
+    long as the user does not try to index into any captures as there are no actual captures. This behavior was a bug in
+    Regex that we duplicated and should now be fixed in the latest Regex (mrabarnett/mrab-regex#439) as well as in
     Backrefs.
 
 ## 5.1

{backrefs-5.7.post1 → backrefs-5.8}/docs/src/markdown/refs.md

@@ -23,7 +23,7 @@ Back\ References      | Description
 `\P{UnicodeProperty}` | Inverse Unicode property character class. Can be used in character classes `[]`. See [Unicode Properties](#unicode-properties) for more info.
 `\PX`                 | Inverse Unicode property character class where `X` is the uppercase letter that represents the General Category property. For instance, `\PL` would be equivalent to `\P{L}` or `\P{Letter}`.
 `[[:alnum:]]`         | Though not really a back reference, support for POSIX style character classes is available. See [POSIX Style Properties](#posix-style-properties) for more info.
-`\N{UnicodeName}`     | Named characters are are normally ignored in Re, but Backrefs adds support for them.
+`\N{UnicodeName}`     | Named characters are normally ignored in Re, but Backrefs adds support for them.
 `\m`                  | Start word boundary. Translates to `\b(?=\w)`.
 `\M`                  | End word boundary. Translates to `\b(?<=\w)`.
 `\h`                  | **Deprecated: Use `\p{Horiz_Space}` instead.** Horizontal whitespace. Equivalent to using `[[:blank:]]` or `[\t\p{Zs}]`.
@@ -73,7 +73,7 @@ Back\ References     | Description
 `\U`                 | Wide Unicode character `\U00000057`. Re doesn't translate this notation in raw strings (`#!py3 r"..."`), and Regex doesn't in format templates in raw strings (`#!py3 r"{} {}"`).  This adds support for them.
 `\u`                 | Narrow Unicode character `\u0057`. Re doesn't translate this notation in raw strings (`#!py3 r"..."`), and Regex doesn't in format templates in raw strings (`#!py3 r"{} {}"`).  This adds support for them.
 `\x`                 | Byte character `\x57`. Re doesn't translate this notation in raw strings (`#!py3 r"..."`), and Regex doesn't in format templates in raw strings (`#!py3 r"{} {}"`).  This adds support for them.
-`\N{UnicodeName}`    | Named characters are are normally ignored in Re, but Backrefs adds support for them.
+`\N{UnicodeName}`    | Named characters are normally ignored in Re, but Backrefs adds support for them.
 
 /// tip
 Complex configurations of casing should work fine.

{backrefs-5.7.post1 → backrefs-5.8}/docs/src/markdown/usage.md

@@ -135,7 +135,7 @@ why.
 1.  Regex's original implementation is very much like it's non-format style replacement accept for two differences: you
     can access individual captures and you cannot use Python string back references such as specifying Unicode via
     `\u<code>`, etc. In Backrefs, we've enhanced the syntax -- for both Re and Regex -- to allow back references to work
-    along side brace replacements. This means you can use string back references and and built-in Backrefs features like
+    along side brace replacements. This means you can use string back references and built-in Backrefs features like
     `\C...\E` or `\L...\E`.
 
     ```pycon3

{backrefs-5.7.post1 → backrefs-5.8}/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.8',
             'Programming Language :: Python :: 3.9',
             'Programming Language :: Python :: 3.10',
             'Programming Language :: Python :: 3.11',

{backrefs-5.7.post1 → backrefs-5.8}/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.8"
+requires-python = ">=3.9"
 authors = [
     { name = "Isaac Muse", email = "Isaac.Muse@gmail.com" },
 ]
@@ -125,6 +125,8 @@ lint.ignore = [
     "RUF012",
     "RUF005",
     "PGH004",
+    "RUF022",
+    "RUF023",
     "RUF100"
 ]
 
@@ -133,7 +135,7 @@ legacy_tox_ini = """
 [tox]
 isolated_build = true
 envlist =
-    py38,py39,py310,py311,py312,
+    py39,py310,py311,py312,py313,
     lint
 
 [testenv]

{backrefs-5.7.post1 → backrefs-5.8}/tests/test_bre.py

@@ -947,17 +947,17 @@ class TestReplaceTemplate(unittest.TestCase):
     def test_format_conversions(self):
         """Test string format conversion paths."""
 
-        self.assertTrue(bre.subf('test', r'{0.index}', 'test').startswith('<built-in method'))
+        self.assertTrue(bre.subf('test', r'{0.index}', 'test').startswith(('<built-in method', '<bound method')))
         self.assertEqual(bre.subf('test', r'{0.__class__.__name__}', 'test'), 'str')
-        self.assertTrue(bre.subf('test', r'{0.index!s}', 'test').startswith('<built-in method'))
+        self.assertTrue(bre.subf('test', r'{0.index!s}', 'test').startswith(('<built-in method', '<bound method')))
         self.assertEqual(bre.subf('test', r'{0.__class__.__name__!s}', 'test'), 'str')
-        self.assertTrue(bre.subf('test', r'{0.index!a}', 'test').startswith('<built-in method'))
+        self.assertTrue(bre.subf('test', r'{0.index!a}', 'test').startswith(('<built-in method', '<bound method')))
 
-        self.assertTrue(bre.subf(b'test', br'{0.index}', b'test').startswith(b'<built-in method'))
+        self.assertTrue(bre.subf(b'test', br'{0.index}', b'test').startswith((b'<built-in method', b'<bound method')))
         self.assertEqual(bre.subf(b'test', br'{0.__class__.__name__}', b'test'), b'bytes')
-        self.assertTrue(bre.subf(b'test', br'{0.index!s}', b'test').startswith(b'<built-in method'))
+        self.assertTrue(bre.subf(b'test', br'{0.index!s}', b'test').startswith((b'<built-in method', b'<bound method')))
         self.assertEqual(bre.subf(b'test', br'{0.__class__.__name__!s}', b'test'), b'bytes')
-        self.assertTrue(bre.subf('test', r'{0.index!a}', 'test').startswith('<built-in method'))
+        self.assertTrue(bre.subf('test', r'{0.index!a}', 'test').startswith(('<built-in method', '<bound method')))
 
     def test_incompatible_strings(self):
         """Test incompatible string types."""

{backrefs-5.7.post1 → backrefs-5.8}/tests/test_bregex.py

@@ -693,17 +693,21 @@ class TestReplaceTemplate(unittest.TestCase):
     def test_format_conversions(self):
         """Test string format conversion paths."""
 
-        self.assertTrue(bregex.subf('test', r'{0.index}', 'test').startswith('<built-in method'))
+        self.assertTrue(bregex.subf('test', r'{0.index}', 'test').startswith(('<built-in method', '<bound method')))
         self.assertEqual(bregex.subf('test', r'{0.__class__.__name__}', 'test'), 'str')
-        self.assertTrue(bregex.subf('test', r'{0.index!s}', 'test').startswith('<built-in method'))
+        self.assertTrue(bregex.subf('test', r'{0.index!s}', 'test').startswith(('<built-in method', '<bound method')))
         self.assertEqual(bregex.subf('test', r'{0.__class__.__name__!s}', 'test'), 'str')
-        self.assertTrue(bregex.subf('test', r'{0.index!a}', 'test').startswith('<built-in method'))
+        self.assertTrue(bregex.subf('test', r'{0.index!a}', 'test').startswith(('<built-in method', '<bound method')))
 
-        self.assertTrue(bregex.subf(b'test', br'{0.index}', b'test').startswith(b'<built-in method'))
+        self.assertTrue(bregex.subf(
+            b'test', br'{0.index}', b'test').startswith((b'<built-in method', b'<bound method'))
+        )
         self.assertEqual(bregex.subf(b'test', br'{0.__class__.__name__}', b'test'), b'bytes')
-        self.assertTrue(bregex.subf(b'test', br'{0.index!s}', b'test').startswith(b'<built-in method'))
+        self.assertTrue(
+            bregex.subf(b'test', br'{0.index!s}', b'test').startswith((b'<built-in method', b'<bound method'))
+        )
         self.assertEqual(bregex.subf(b'test', br'{0.__class__.__name__!s}', b'test'), b'bytes')
-        self.assertTrue(bregex.subf('test', r'{0.index!a}', 'test').startswith('<built-in method'))
+        self.assertTrue(bregex.subf('test', r'{0.index!a}', 'test').startswith(('<built-in method', '<bound method')))
 
     def test_incompatible_strings(self):
         """Test incompatible string types."""

{backrefs-5.7.post1 → backrefs-5.8}/tools/unipropgen.py

@@ -744,9 +744,9 @@ def gen_binary(table, output, ascii_props=False, append=False, prefix="", aliase
     # One off Unicode property found under https://unicode.org/reports/tr18/#Compatibility_Properties
     # `Word: [\p{alnum}\p{M}\p{Pc}\p{JoinControl}]`
     s = set(binary["alnum"])
-    s |= set(table['m']['c'])
-    s |= set(table['m']['e'])
-    s |= set(table['m']['n'])
+    for k, v in table['m'].items():
+        if not k.startswith('^'):
+            s |= set(v)
     s |= set(table["p"]["c"])
     s |= set(binary["joincontrol"])
     binary["word"] = list(s)

backrefs-5.7.post1/backrefs/_bregex_typing.py

@@ -1,13 +0,0 @@
-"""Typing objects for the Regex library."""
-from typing import AnyStr
-import regex  # type: ignore[import]
-import sys
-
-from typing import _alias  # type: ignore[attr-defined]
-
-if sys.version_info >= (3, 9):
-    Pattern = _alias(type(regex.compile('')), 1)
-    Match = _alias(type(regex.compile('').match('')), 1)
-else:
-    Pattern = _alias(type(regex.compile('')), AnyStr)
-    Match = _alias(type(regex.compile('').match('')), AnyStr)