backrefs 5.9__tar.gz → 6.0__tar.gz

{backrefs-5.9 → backrefs-6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: backrefs
-Version: 5.9
+Version: 6.0
 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>

{backrefs-5.9 → backrefs-6.0}/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, 9, 0, "final")
+__version_info__ = Version(6, 0, 0, "final")
 __version__ = __version_info__._get_canonical()

{backrefs-5.9 → backrefs-6.0}/backrefs/_bre_parse.py

@@ -37,11 +37,19 @@ _STANDARD_ESCAPES = frozenset(('a', 'b', 'f', 'n', 'r', 't', 'v'))
 _CURLY_BRACKETS = frozenset(('{', '}'))
 _PROPERTY_STRIP = frozenset((' ', '-', '_'))
 _PROPERTY = _WORD | _DIGIT | _PROPERTY_STRIP
-_GLOBAL_FLAGS = frozenset(('a', 'u', 'L'))
-_SCOPED_FLAGS = frozenset(('i', 'm', 's', 'u', 'x'))
+_GLOBAL_FLAGS = frozenset(('a', 'i', 'L', 'm', 's', 'u', 'x'))
+_SCOPED_FLAGS = frozenset(('i', 'm', 's', 'x'))
+_SCOPED_END = frozenset((':', ')'))
 
 _CURLY_BRACKETS_ORD = frozenset((0x7b, 0x7d))
 
+_COMPATIBILITY_PROPERTIES = frozenset(
+    (
+        'alpha', 'lower', 'upper', 'punct', 'digit', 'xdigit', 'alnum',
+        'space', 'blank', 'cntrl', 'graph', 'print', 'word'
+    )
+)
+
 # Case upper or lower
 _UPPER = 1
 _LOWER = 2
@@ -173,20 +181,24 @@ class _SearchParser(Generic[AnyStr]):
     def flags(self, text: str, scoped: bool = False) -> None:
         """Analyze flags."""
 
+        flags = text.split('-')
+        enable = flags[0]
+        disable = flags[1] if len(flags) > 1 else ''
+
         global_retry = False
-        if ('a' in text or 'L' in text) and self.unicode:
+        if ('a' in enable or 'L' in enable) and self.unicode:
             self.unicode = False
             if not scoped:
                 self.temp_global_flag_swap["unicode"] = True
                 global_retry = True
-        elif 'u' in text and not self.unicode and not self.is_bytes:
+        elif 'u' in enable and not self.unicode and not self.is_bytes:
             self.unicode = True
             if not scoped:
                 self.temp_global_flag_swap["unicode"] = True
                 global_retry = True
-        if '-x' in text and self.verbose:
+        if 'x' in disable and self.verbose:
             self.verbose = False
-        elif 'x' in text and not self.verbose:
+        elif 'x' in enable and not self.verbose:
             self.verbose = True
             if not scoped:
                 self.temp_global_flag_swap["verbose"] = True
@@ -253,7 +265,15 @@ class _SearchParser(Generic[AnyStr]):
             else:
                 raise SyntaxError(f"Missing or unmatched '{{' at {index}!") from e
 
-        return ''.join(prop).lower(), ''.join(value).lower()
+        p = ''.join(prop).lower()
+        v = ''.join(value).lower()
+
+        # Ensure when using POSIX form, that any property considered a compatibility property uses the POSIX form.
+        # POSIX form is not guaranteed to be different from standard form and sometimes is just an alias for standard.
+        if brackets and p in _COMPATIBILITY_PROPERTIES:
+            p = 'posix' + p
+
+        return p, v
 
     def get_named_unicode(self, i: _util.StringIter) -> str:
         """Get Unicode name."""
@@ -345,51 +365,56 @@ class _SearchParser(Generic[AnyStr]):
 
         return ''.join(value)
 
-    def get_flags(self, i: _util.StringIter, scoped: bool = False) -> str | None:
-        """Get flags."""
+    def get_flags(self, i: _util.StringIter) -> tuple[str | None, bool]:
+        """
+        Get flags.
+
+        In Re, flags are quite predictable when global or scoped.
+        Global can never be disabled with minus, and never have a `:` after them.
+        The global flag set is also very specific, but can be used as enablers in scoped.
+
+        The returned scoped status will indicate whether flags are generally considered
+        scoped flags or global flags.
+        """
 
         index = i.index
         value = ['(']
         toggle = False
-        end = ':' if scoped else ')'
+        smells_scoped = False
         try:
             c = next(i)
             if c != '?':
                 i.rewind(1)
-                return None
+                return None, False
             value.append(c)
             c = next(i)
-            while c != end:
+            while c not in _SCOPED_END:
                 if toggle:
                     if c not in _SCOPED_FLAGS:
                         raise ValueError('Bad scope')
-                    toggle = False
-                elif scoped and c == '-':
+                elif c == '-':
+                    smells_scoped = True
                     toggle = True
-                elif scoped and c in _GLOBAL_FLAGS:
-                    raise ValueError("Bad flag")
-                elif c not in _GLOBAL_FLAGS and c not in _SCOPED_FLAGS:
+                elif c not in _GLOBAL_FLAGS:
                     raise ValueError("Bad flag")
                 value.append(c)
                 c = next(i)
+            if smells_scoped and c != ':':
+                raise ValueError("Bad flag")
+            elif c == ':':
+                smells_scoped = True
             value.append(c)
         except Exception:
             i.rewind(i.index - index)
             value = []
 
-        return ''.join(value) if value else None
+        return ''.join(value) if value else None, smells_scoped
 
     def subgroup(self, t: str, i: _util.StringIter) -> list[str]:
         """Handle parenthesis."""
 
         current = []  # type: list[str]
 
-        # (?flags)
-        flags = self.get_flags(i)
-        if flags:
-            self.flags(flags[2:-1])
-            return [flags]
-
         # (?#comment)
         comments = self.get_comments(i)
         if comments:
@@ -398,11 +423,13 @@ class _SearchParser(Generic[AnyStr]):
         verbose = self.verbose
         unicode_flag = self.unicode
 
-        # (?flags:pattern)
-        flags = self.get_flags(i, True)
+        # (?flags:pattern) or (?flags)
+        flags, scoped = self.get_flags(i)
         if flags:  # pragma: no cover
             t = flags
-            self.flags(flags[2:-1], scoped=True)
+            self.flags(flags[2:-1], scoped=scoped)
+            if not scoped:
+                return [flags]
 
         current = []
         try:

{backrefs-5.9 → backrefs-6.0}/backrefs/_bregex_parse.py

@@ -30,9 +30,10 @@ _STANDARD_ESCAPES = frozenset(('a', 'b', 'f', 'n', 'r', 't', 'v'))
 _CURLY_BRACKETS = frozenset(('{', '}'))
 _PROPERTY_STRIP = frozenset((' ', '-', '_'))
 _PROPERTY = _WORD | _DIGIT | _PROPERTY_STRIP
-_GLOBAL_FLAGS = frozenset(('L', 'a', 'b', 'e', 'r', 'u', 'p'))
-_SCOPED_FLAGS = frozenset(('i', 'm', 's', 'f', 'w', 'x'))
+_GLOBAL_FLAGS = frozenset(('b', 'e', 'p', 'r', 'u'))
+_SCOPED_FLAGS = frozenset(('a', 'f', 'i', 'L', 'm', 's', 'u', 'w', 'x'))
 _VERSIONS = frozenset(('0', '1'))
+_SCOPED_END = frozenset((':', ')'))
 
 _CURLY_BRACKETS_ORD = frozenset((0x7b, 0x7d))
 
@@ -163,21 +164,25 @@ class _SearchParser(Generic[AnyStr]):
     def flags(self, text: str, scoped: bool = False) -> None:
         """Analyze flags."""
 
+        flags = text.split('-')
+        enable = flags[0]
+        disable = flags[1] if len(flags) > 1 else ''
+
         global_retry = False
-        if (self.version == _regex.V1 or scoped) and '-x' in text and self.verbose:
+        if (self.version == _regex.V1 or scoped) and 'x' in disable and self.verbose:
             self.verbose = False
-        elif 'x' in text and not self.verbose:
+        elif 'x' in enable and not self.verbose:
             self.verbose = True
             if not scoped and self.version == _regex.V0:
                 self.temp_global_flag_swap['verbose'] = True
                 global_retry = True
-        if 'V0' in text and self.version == _regex.V1:  # pragma: no cover
+        if 'V0' in enable and self.version == _regex.V1:  # pragma: no cover
             # Default is V0 if none is selected,
             # so it is unlikely that this will be selected.
             self.temp_global_flag_swap['version'] = True
             self.version = _regex.V0
             global_retry = True
-        elif "V1" in text and self.version == _regex.V0:
+        elif "V1" in enable and self.version == _regex.V0:
             self.temp_global_flag_swap['version'] = True
             self.version = _regex.V1
             global_retry = True
@@ -260,54 +265,61 @@ class _SearchParser(Generic[AnyStr]):
 
         return ''.join(value) if value else None
 
-    def get_flags(self, i: _util.StringIter, version0: bool, scoped: bool = False) -> str | None:
-        """Get flags."""
+    def get_flags(self, i: _util.StringIter) -> tuple[str | None, bool]:
+        """
+        Get flags.
+
+        Regex is more difficult to determine when flags are used in a global and scoped context.
+        There is a specific list of global flags, but they can be used in scoped notation and will still
+        be considered global, but that does not mean other flags are global. Additionally, flags that can be
+        scoped can also used be used in global syntax, but can be disabled with a minus unlike in RE.
+
+        Bregex only cares about capturing the "verbose" flag and the version flags. Version flags are always
+        global and verbose flags will be scoped based on whether they are in a scoped group. The returned
+        "scoped" parameter only refers to "verbose".
+        """
 
         index = i.index
         value = ['(']
         version = False
         toggle = False
-        end = ':' if scoped else ')'
+        smells_scoped = False
         try:
             c = next(i)
             if c != '?':
                 i.rewind(1)
-                return None
+                return None, False
             value.append(c)
             c = next(i)
-            while c != end:
+            while c not in _SCOPED_END:
                 if toggle:
                     if c not in _SCOPED_FLAGS:
                         raise ValueError('Bad scope')
-                    toggle = False
-                elif (not version0 or scoped) and c == '-':
-                    toggle = True
                 elif version:
                     if c not in _VERSIONS:
                         raise ValueError('Bad version')
                     version = False
+                elif c == '-':
+                    toggle = True
                 elif c == 'V':
                     version = True
                 elif c not in _GLOBAL_FLAGS and c not in _SCOPED_FLAGS:
                     raise ValueError("Bad flag")
                 value.append(c)
                 c = next(i)
+            if c == ':':
+                smells_scoped = True
+
             value.append(c)
         except Exception:
             i.rewind(i.index - index)
             value = []
 
-        return ''.join(value) if value else None
+        return ''.join(value) if value else None, smells_scoped
 
     def subgroup(self, t: str, i: _util.StringIter) -> list[str]:
         """Handle parenthesis."""
 
-        # (?flags)
-        flags = self.get_flags(i, self.version == _regex.V0)
-        if flags:
-            self.flags(flags[2:-1])
-            return [flags]
-
         # (?#comment)
         comments = self.get_comments(i)
         if comments:
@@ -315,11 +327,14 @@ class _SearchParser(Generic[AnyStr]):
 
         verbose = self.verbose
 
-        # (?flags:pattern)
-        flags = self.get_flags(i, (self.version == _regex.V0), True)
+        # (?flags:pattern) or (?flags)
+        # "scoped" only refers to verbose
+        flags, scoped = self.get_flags(i)
         if flags:
             t = flags
-            self.flags(flags[2:-1], scoped=True)
+            self.flags(flags[2:-1], scoped=scoped)
+            if not scoped:
+                return [flags]
 
         current = []  # type: list[str]
         try:

{backrefs-5.9 → backrefs-6.0}/docs/src/markdown/about/changelog.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 6.0
+
+-   **NEW**: POSIX character classes will now always use POSIX compatibility rules instead of Unicode standard rules,
+    if any are specified in the Unicode specification. The affected character classes are: `[[:alnum:]]`, `[[:digit:]]`,
+    `[[:xdigit:]]`, and  `[[:punct:]]`. To explicitly use standard Unicode rules for these compatibility properties, use
+    the Unicode property form instead: `[\p{Alnum}]`, `[\p{Digit}]`, `[\p{Punct}]`, or `[\p{XDigit}]`. This has changed
+    to ensure no confusion for users expecting compatible POSIX style character class properties.
+-   **FIX**: Scoped ASCII/Unicode flags (`(?a:pattern)`/`(?u:pattern)`) should be respected for Unicode properties in
+    `bre` and will ensure ASCII or Unicode range if used.
+-   **FIX**: Fix issues related to detecting disabled scoped flags.
+
 ## 5.9
 
 -   **NEW**: Add support for Python 3.14.
@@ -28,8 +39,8 @@
 
 ## 5.5
 
--   **NEW**: `\e` and `\h` have both been deprecated in 6.0. Please migrate to using `\x1b` and `\p{Horiz_Space}` in
-    their respective place.
+-   **NEW**: `\e` and `\h` have both been deprecated. Please migrate to using `\x1b` and `\p{Horiz_Space}` in their
+    respective place.
 -   **FIX**: Fix flag issue with `sub` functions.
 
 ## 5.4

{backrefs-5.9 → backrefs-6.0}/docs/src/markdown/refs.md

@@ -204,7 +204,7 @@ When it comes to short names, each new Unicode version, there is a risk that new
 with existing names and/or aliases. Currently, most of the conflicts involve the Block properties. To reduce
 friction, they are evaluated last.
 
-Generally, it is discouraged to use short names for Block properties. But the option is still supported, but Block 
+Generally, it is discouraged to use short names for Block properties. But the option is still supported, but Block
 properties will be evaluated last. There are currently no known conflicts with `In*` properties, but in future
 Unicode versions there could.
 
@@ -259,67 +259,18 @@ Verbose\ Property\ Form            | Terse\ Property\ Form
  `Line_Separator`                  | `Zl`
  `Paragraph_Separator`             | `Z`
 
-### POSIX Style Properties
-
-/// new | New in 5.0
-5.0 brings significant improvements and bug fixes to Unicode property handling. Properties are sensitive to the
-`ASCII` flag along with more extensive testing and bug fixes. Additionally, POSIX style properties are now just
-an extension of normal Unicode properties. All the POSIX names are available and now conform to
-the [Unicode specification for POSIX compatibility](https://unicode.org/reports/tr18/#Compatibility_Properties).
-Read on to learn more.
-///
-
-Backrefs allows for POSIX style properties in the form `[:name:]`. These properties can only be used inside character
-classes and are another form for expressing Unicode properties. Any Unicode property that can be expressed via the
-`\p{name}` form can also be expressed in the `[:name:]` form. To illustrate, the following are all the same:
-
--   `[[:upper:]]` == `[\p{upper}]`
--   `[[:^upper:]]` == `[\p{^upper}]`
--   `[[:alpha=yes:]]` == `[\p{alpha=yes}]`
-
-A number of POSIX property names are available via compatibility properties as outlined in the
-[Unicode specification for POSIX compatibility](https://unicode.org/reports/tr18/#Compatibility_Properties). These
-properties will operate in the Unicode range and the ASCII range depending on the regular expression mode. These
-patterns, like all Unicode properties, are sensitive to the `ASCII` flag (or `LOCALE` which will treat them as `ASCII`).
-
-It is important to note that whether used in the form `[[:name:]]` or `\p{name}`, each POSIX name is available both with
-and without the `posix` prefix, but it is recommended to use the `posix` prefix to get the POSIX definition of the
-pattern as number of patterns have both a POSIX and Unicode definition that differ. The
-[Unicode specification for POSIX compatibility](https://unicode.org/reports/tr18/#Compatibility_Properties) outlines all
-the POSIX compatible properties and the ones which have dual definitions: `punct`, `alnum`, `digit`, and `xdigit` all
-have a Unicode standard and a POSIX compatibility variant and must be accessed with the `posix` prefix to get the POSIX
-form.
-
-In the table below, patterns with `--` mean `[[in this] -- [but not this]]`.
-
-\[:posix:] | \\p\{Posix}   | ASCII                                             | Unicode
----------- | ------------- | ------------------------------------------------- | -------
-`alpha`    | `Alpha`       | `[a-zA-Z]`                                        | `\p{Alphabetic}`
-`alnum`    | `PosixAlnum`  | `[[:alpha:][:digit:]]`                            | `[[:alpha:][:digit:]]`
-`blank`    | `Blank`       | `[ \t]`                                           | `[\p{Zs}\t]`
-`cntrl`    | `Cntrl`       | `[\x00-\x1F\x7F]`                                 | `\p{Cc}`
-`digit`    | `PosixDigit`  | `[0-9]`                                           | `[0-9]`
-`graph`    | `Graph`       | `[^ [:cntrl:]]`                                   | `[^[:space:][:cntrl:]\p{Cn}\p{Cs}]`
-`lower`    | `Lower`       | `[a-z]`                                           | `[\p{Lowercase}]`
-`print`    | `Print`       | `[[:graph:] ]`                                    | `[[\p{P}\p{S}]--[\p{alpha}]]`
-`punct`    | `PosixPunct`  | ``[!\"\#$%&'()*+,\-./:;<=>?@\[\\\]^_`{}~]`` | `[[[:graph:][:blank:]]--[[:cntrl:]]]`
-`space`    | `Space`       | `[ \t\r\n\v\f]`                                   | `[\p{Whitespace}]`
-`upper`    | `Upper`       | `[A-Z]`                                           | `[\p{Uppercase}]`
-`xdigit`   | `PosixXDigit` | `[A-Fa-f0-9]`                                     | `[A-Fa-f0-9]`
-
 ### Compatibility Properties
 
 /// new | New in 5.0
 While many of the properties were available before 5.0, `word` is newly available. And all the properties now
-conform to the [Unicode specification for POSIX compatibility](https://unicode.org/reports/tr18/#Compatibility_Properties).
+conform to the [Unicode specification for compatibility properties](https://unicode.org/reports/tr18/#Compatibility_Properties).
 ///
 
-[Unicode specification for POSIX compatibility][unicode-posix] defines a number of properties, many of which double as
-[Posix properties](#posix-style-properties). These properties can be accessed via `\p{name}` or `[[:name:]]`.
-
-In the table below, patterns with `--` mean `[[in this] -- [but not this]]`.
+[Unicode specification for compatibility properties][unicode-posix] defines a number of properties for use in regular
+expressions. The table below shows the names of these properties along with their standard rules as implemented in
+Backrefs. Patterns with `--` mean `[[in this] -- [but not this]]`.
 
-\\p\{Posix}   | Unicode
+\\p\{name}    | Unicode
 ------------- | -------
 `Alpha`       | `\p{Alphabetic}`
 `Alnum`       | `[\p{Alpha}\p{Digit}]`
@@ -328,9 +279,84 @@ In the table below, patterns with `--` mean `[[in this] -- [but not this]]`.
 `Digit`       | `\p{Nd}`
 `Graph`       | `[^\p{Space}\p{Cntrl}\p{Cn}\p{Cs}]`
 `Lower`       | `\p{Lowercase}`
-`Print`       | `[[\p{P}\p{S}]--[\p{Alpha}]]`
+`Print`       | `[\p{graph}\p{blank}--\p{cntrl}]`
 `Punct`       | `\p{P}`
 `Space`       | `\p{Whitespace}`
 `Upper`       | `\p{Uppercase}`
 `Word`        | `[\p{Alnum}\p{M}\p{Pc}\p{JoinControl}]`
 `XDigit`      | `[\p{Nd}\p{HexDigit}]`
+
+The [Unicode specification for compatibility properties](https://unicode.org/reports/tr18/#Compatibility_Properties)
+also defines rules for POSIX compatibility which provides modifications to the standard recommendation required to meet
+the formal requirements of POSIX, and also to maintain (as much as possible) compatibility with the POSIX usage in
+practice.
+
+To accommodate these POSIX compatible rules, Backrefs defines POSIX property names for all the compatibility properties.
+For any that do not have special accommodations, the POSIX property name will act as an alias for the standard Unicode
+name. In all, four properties are specifically affected with POSIX specific accommodations: `Alnum`, `Digit`, `Punct`,
+and `XDigit`.
+
+\\p\{name}    | Unicode
+------------- | -------
+`PosixAlpha`  | `\p{Alpha}`
+`PosixAlnum`  | `[\p{Alpha}\p{PosixDigit}]`
+`PosixBlank`  | `\p{Blank}`
+`PosixCntrl`  | `\p{Cntrl}`
+`PosixDigit`  | `[0-9]`
+`PosixGraph`  | `\p{Graph}`
+`PosixLower`  | `\p{Lower}`
+`PosixPrint`  | `\p{Print}`
+`PosixPunct`  | `[[\p{P}\p{S}]--[\p{alpha}]]`
+`PosixSpace`  | `\p{Space}`
+`PosixUpper`  | `\p{Uppper}`
+`PosixWord`   | `\p{Word}`
+`PosixXDigit` | `[A-Fa-f0-9]`
+
+### POSIX Character Classes
+
+/// new | New in 6.0
+POSIX character classes in the form of `[:name:]` are now forced to always use POSIX compatible rules if available.
+These rules are defined in the [Unicode specification for compatibility properties]
+(https://unicode.org/reports/tr18/#Compatibility_Properties).
+///
+
+Backrefs allows for POSIX style character classes in the form of `[:name:]`. These properties can only be used inside
+character classes, e.g. `[[:name:]]`.
+
+When using POSIX character classes, all character classes will use the matching rules as stated in the
+[Unicode specification for compatibility properties](https://unicode.org/reports/tr18/#Compatibility_Properties). If
+there are specific rules for POSIX compatibility, those will be used in the bracket expression instead of the Unicode
+standard form. For all others, the Unicode standard form will be used.
+
+The table below outlines the supported POSIX names that can be used in the form `[:name:]` and details the differences
+in rules if using ASCII mode or Unicode mode.
+
+\[:posix:] | ASCII                                                         | Unicode
+---------- | ------------------------------------------------------------- | -------
+`alpha`    | `[a-zA-Z]`                                                    | `\p{Alphabetic}`
+`alnum`    | `[[:alpha:][:digit:]]`                                        | `[[:alpha:][:digit:]]`
+`blank`    | `[ \t]`                                                       | `[\p{Zs}\t]`
+`cntrl`    | `[\x00-\x1F\x7F]`                                             | `\p{Cc}`
+`digit`    | `[0-9]`                                                       | `[0-9]`
+`graph`    | `[^ [:cntrl:]]`                                               | `[^[:space:][:cntrl:]\p{Cn}\p{Cs}]`
+`lower`    | `[a-z]`                                                       | `[\p{Lowercase}]`
+`print`    | `[[:graph:] ]`                                                | `[[[:graph:][:blank:]]--[[:cntrl:]]]`
+`punct`    | ``[!"#$%&'()*+,\-./:;<=>?@[\]^_`{|}~]``                       | `[[\p{P}\p{S}]--[\p{alpha}]]`
+`space`    | `[ \t\r\n\v\f]`                                   			   | `[\p{Whitespace}]`
+`upper`    | `[A-Z]`                                           			   | `[\p{Uppercase}]`
+`word`     | `[A-Za-z0-9_]`												   | `[\p{Alnum}\p{M}\p{Pc}\p{JoinControl}]`
+`xdigit`   | `[A-Fa-f0-9]`                                     			   | `[A-Fa-f0-9]`
+
+/// Tip
+Using POSIX character classes is equivalent to using Unicode compatibility properties for POSIX, e.g. `[[:punct:]]`
+== `\p{Posix Punct}`.
+///
+
+POSIX style character classes have also been extended to allow for specifying normal Unicode properties as well. Any
+Unicode property, outside the compatibility properties, will be accepted in the bracket extension form and behave just
+like normal Unicode properties. To illustrate, the following are equivalent:
+
+-   `[[:math:]]` == `[\p{math}]`
+-   `[[:scx=latin:]]` == `[\p{scx: latin}]`
+-   `[[:^scx=latin:]]` == `[\P{scx: latin}]`
+

{backrefs-5.9 → backrefs-6.0}/tests/test_bre.py

@@ -11,6 +11,7 @@ import copy
 
 PY39_PLUS = (3, 9) <= sys.version_info
 PY311_PLUS = (3, 11) <= sys.version_info
+PY313_PLUS = (3, 13) <= sys.version_info
 
 if PY311_PLUS:
     import re._constants as _constants
@@ -21,6 +22,20 @@ else:
 class TestSearchTemplate(unittest.TestCase):
     """Search template tests."""
 
+    def test_multi_disable_flag(self):
+        """Test when multiple flags are disabled."""
+
+        self.assertTrue(bre.match(r'(?-ix:Test Test)', 'Test Test', flags=bre.IGNORECASE | bre.VERBOSE))
+        self.assertTrue(bre.match(r'(?s-ix:Test Test)', 'Test Test', flags=bre.IGNORECASE | bre.VERBOSE))
+
+    def test_inline_unicode(self):
+        """Test inline Unicode/ASCII cases."""
+
+        self.assertTrue(bre.match(r'\p{N}', '\uff19', flags=bre.ASCII) is None)
+        self.assertTrue(bre.match(r'(?u:\p{N})', '\uff19', flags=bre.ASCII) is not None)
+        self.assertTrue(bre.match(r'\p{N}', '\uff19', flags=bre.UNICODE) is not None)
+        self.assertTrue(bre.match(r'(?a:\p{N})', '\uff19', flags=bre.UNICODE) is None)
+
     def test_custom_binary_properties(self):
         """Test new custom binary properties."""
 
@@ -1986,6 +2001,16 @@ class TestReplaceTemplate(unittest.TestCase):
 class TestExceptions(unittest.TestCase):
     """Test Exceptions."""
 
+    def test_bad_flag(self):
+        """Test bad flag."""
+
+        if PY313_PLUS:
+            with self.assertRaises(re.PatternError):
+                bre.compile(r'(?-i)')
+        else:
+            with self.assertRaises(re.error):
+                bre.compile(r'(?-i)')
+
     def test_format_existing_group_no_match_with_index(self):
         """Test format group with no match and attempt at indexing."""
 

{backrefs-5.9 → backrefs-6.0}/tests/test_bregex.py

@@ -20,6 +20,12 @@ PY39_PLUS = (3, 9) <= sys.version_info
 class TestSearchTemplate(unittest.TestCase):
     """Search template tests."""
 
+    def test_multi_disable_flag(self):
+        """Test when multiple flags are disabled."""
+
+        self.assertTrue(bregex.match(r'(?-ix:Test Test)', 'Test Test', flags=bregex.IGNORECASE | bregex.VERBOSE))
+        self.assertTrue(bregex.match(r'(?s-ix:Test Test)', 'Test Test', flags=bregex.IGNORECASE | bregex.VERBOSE))
+
     def test_named_lists_attribute(self):
         """Test named list attribute."""
 

{backrefs-5.9 → backrefs-6.0}/tools/unipropgen.py

@@ -740,16 +740,6 @@ def gen_binary(table, output, ascii_props=False, append=False, prefix="", aliase
 
     gen_uposix(table, binary, ascii_props)
 
-    # 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"])
-    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)
-
     if aliases:
         for v in aliases.get('binary', {}).values():
             if v not in binary and '^' + v not in binary:
@@ -881,9 +871,14 @@ def gen_uposix(table, posix_table, ascii_props):
     s -= set(posix_table["posixcntrl"])
     posix_table["posixprint"] = list(s)
 
-    # `ASCII: [\x00-\x7F]`
-    s = set(range(0, 0x7F + 1))
-    posix_table["posixascii"] = list(s)
+    # `Word: [\p{alnum}\p{M}\p{Pc}\p{JoinControl}]`
+    s = set(posix_table["alnum"])
+    for k, v in table['m'].items():
+        if not k.startswith('^'):
+            s |= set(v)
+    s |= set(table["p"]["c"])
+    s |= set(posix_table["joincontrol"])
+    posix_table['posixword'] = list(s)
 
 
 def gen_alias(nonbinary, binary, output):
@@ -904,9 +899,11 @@ def gen_alias(nonbinary, binary, output):
         'posixlower': 'lowercase',
         'posixupper': 'uppercase',
         'posixspace': 'whitespace',
+        'posixascii': 'basiclatin',
         'blank': 'posixblank',
         'graph': 'posixgraph',
-        'print': 'posixprint'
+        'print': 'posixprint',
+        'word': 'posixword'
     }
     toplevel = (
         'catalog', 'enumerated', 'numeric', 'miscellaneous'