pybear 0.2.2__tar.gz → 0.2.3__tar.gz

{pybear-0.2.2 → pybear-0.2.3}/CHANGELOG.md

@@ -6,6 +6,29 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 
+## [0.2.3] - 2025-09-30
+
+### Added
+- None
+
+### Changed
+- feature_extraction.text
+    - TextLookup, TextLookupRealTime:
+        Add the ability to take re.compile objects in DELETE_ALWAYS, 
+        SKIP_ALWAYS, REPLACE_ALWAYS, and SPLIT_ALWAYS init parameters.
+
+### Deprecated
+- None
+
+### Removed
+- None
+
+### Fixed
+- None
+
+### Security
+- None
+
 ## [0.2.2] - 2025-09-08
 
 ### Added

{pybear-0.2.2 → pybear-0.2.3}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: pybear
-Version: 0.2.2
+Version: 0.2.3
 Summary: Python modules for miscellaneous data analytics applications
 License: BSD-3-Clause
+License-File: LICENSE
 Keywords: python data analytics scikit-API text
 Author: Bill Sousa
 Author-email: WKSJR99@msn.com
@@ -14,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: joblib (>=1.3.0)
 Requires-Dist: numpy (>=2.1.0)
 Requires-Dist: pandas (>=2.2.3)

{pybear-0.2.2 → pybear-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pybear"
-version = "0.2.2"
+version = "0.2.3"
 description = "Python modules for miscellaneous data analytics applications"
 license = "BSD-3-clause"
 authors = ["Bill Sousa <WKSJR99@msn.com>"]

{pybear-0.2.2 → pybear-0.2.3}/src/pybear/feature_extraction/text/_AutoTextCleaner/AutoTextCleaner.py

@@ -302,13 +302,13 @@ class AutoTextCleaner(
 
         auto_delete: NotRequired[bool]
 
-        DELETE_ALWAYS: NotRequired[Sequence[str] | None]
+        DELETE_ALWAYS: NotRequired[Sequence[str | re.Pattern[str]] | None]
 
-        REPLACE_ALWAYS: NotRequired[dict[str, str] | None]
+        REPLACE_ALWAYS: NotRequired[dict[str | re.Pattern[str], str] | None]
 
-        SKIP_ALWAYS: NotRequired[Sequence[str] | None]
+        SKIP_ALWAYS: NotRequired[Sequence[str | re.Pattern[str]] | None]
 
-        SPLIT_ALWAYS: NotRequired[dict[str, Sequence[str]] | None]
+        SPLIT_ALWAYS: NotRequired[dict[str | re.Pattern[str], Sequence[str]] | None]
 
         remove_empty_rows: NotRequired[bool]
 

{pybear-0.2.2 → pybear-0.2.3}/src/pybear/feature_extraction/text/_AutoTextCleaner/_type_aliases.py

@@ -56,10 +56,10 @@ class LexiconLookupType(TypedDict):
     auto_split: NotRequired[bool]
     auto_add_to_lexicon: NotRequired[bool]
     auto_delete: NotRequired[bool]
-    DELETE_ALWAYS: NotRequired[Sequence[str] | None]
-    REPLACE_ALWAYS: NotRequired[dict[str, str] | None]
-    SKIP_ALWAYS: NotRequired[Sequence[str] | None]
-    SPLIT_ALWAYS: NotRequired[dict[str, Sequence[str]] | None]
+    DELETE_ALWAYS: NotRequired[Sequence[str | re.Pattern[str]] | None]
+    REPLACE_ALWAYS: NotRequired[dict[str | re.Pattern[str], str] | None]
+    SKIP_ALWAYS: NotRequired[Sequence[str | re.Pattern[str]] | None]
+    SPLIT_ALWAYS: NotRequired[dict[str | re.Pattern[str], Sequence[str]] | None]
     remove_empty_rows: NotRequired[bool]
     verbose: NotRequired[bool]
 

{pybear-0.2.2 → pybear-0.2.3}/src/pybear/feature_extraction/text/_AutoTextCleaner/_validation/_lexicon_lookup.py

@@ -43,10 +43,10 @@ def _val_lexicon_lookup(
         auto_split: NotRequired[bool]
         auto_add_to_lexicon: NotRequired[bool]
         auto_delete: NotRequired[bool]
-        DELETE_ALWAYS: NotRequired[Sequence[str] | None]
-        REPLACE_ALWAYS: NotRequired[dict[str, str] | None]
-        SKIP_ALWAYS: NotRequired[Sequence[str] | None]
-        SPLIT_ALWAYS: NotRequired[dict[str, Sequence[str]] | None]
+        DELETE_ALWAYS: NotRequired[Sequence[str | re.Pattern[str]] | None]
+        REPLACE_ALWAYS: NotRequired[dict[str | re.Pattern[str], str] | None]
+        SKIP_ALWAYS: NotRequired[Sequence[str | re.Pattern[str]] | None]
+        SPLIT_ALWAYS: NotRequired[dict[str | re.Pattern[str], Sequence[str]] | None]
         remove_empty_rows: NotRequired[bool]
         verbose: NotRequired[bool]
 

{pybear-0.2.2 → pybear-0.2.3}/src/pybear/feature_extraction/text/_TextLookup/TextLookup.py

@@ -14,6 +14,7 @@ from typing_extensions import Self
 import numpy.typing as npt
 
 from copy import deepcopy
+import re
 
 import numpy as np
 import pandas as pd
@@ -26,6 +27,8 @@ from ._shared._transform._manual_word_splitter import _manual_word_splitter
 from ._shared._transform._quasi_auto_word_splitter import _quasi_auto_word_splitter
 from ._shared._transform._word_editor import _word_editor
 
+from ._shared._search_always_list import _search_always_list
+
 from ._shared._type_aliases import (
     XContainer,
     WipXContainer
@@ -82,13 +85,13 @@ class TextLookup(_TextLookupMixin):
     the word to the :attr:`DELETE_ALWAYS_` attribute and go to the next
     word, until all the words in the text are exhausted. In these cases,
     TL can never proceed into manual mode. To allow TL to go into manual
-    mode, `auto_delete` and `auto_add_to_lexicon` both must be False.
+    mode, both `auto_delete` and `auto_add_to_lexicon` must be False.
 
     In manual mode, when TL encounters a word that is not in the
     `Lexicon`, the user will be prompted with an interactive menu for an
     action. Choices that are always presented include: 'skip always',
     'delete always', 'replace always', and 'split always'. Conditionally,
-    if `update_lexicon`. is True, an 'add to lexicon' option is also
+    if `update_lexicon` is True, an 'add to lexicon' option is also
     presented. If you choose something from the 'always' group, the word
     goes into a 'holder' object for the selected action so that TL knows
     how to handle it during transform. TL does not have the ability to
@@ -98,13 +101,6 @@ class TextLookup(_TextLookupMixin):
     the operation/word combinations do not track the exact locations of
     individual words.
 
-    When you are in the manual text lookup process and are entering words
-    at the prompts to replace unknown words in your text, whatever is
-    entered is inserted into your text exactly as entered by you. You
-    must enter the text exactly as you want it in the cleaned output. If
-    normalizing the text is important to you, you must enter the text in
-    the case that you want in the output, TL will not do it for you.
-
     The holder objects are all accessible attributes in the TL public
     API. See the Attributes section for more details. These holder
     objects can also be passed at instantiation to give TL a head-start
@@ -126,7 +122,7 @@ class TextLookup(_TextLookupMixin):
 
     TL always looks for special instructions before looking to see if
     a word is in the `Lexicon`. Otherwise, if TL checked the word against
-    the `Lexicon` first and the word is it`, TL would go to the next
+    the `Lexicon` first and the word is in it, TL would go to the next
     word automatically. Doing it in this way allows for users to give
     special instructions for words already in the `Lexicon`. Let's say
     there is a word in the `Lexicon` but you want to delete it from your
@@ -166,6 +162,13 @@ class TextLookup(_TextLookupMixin):
     pybear `Lexicon` with your own words of varying capitalization, TL
     honors your capitalization scheme.
 
+    When you are in the manual text lookup process and are entering words
+    at the prompts to replace unknown words in your text, whatever is
+    entered is inserted into your text exactly as entered by you. You
+    must enter the text exactly as you want it in the cleaned output. If
+    normalizing the text is important to you, you must enter the text in
+    the case that you want in the output, TL will not do it for you.
+
     If TL encounters a word during transform that was not seen during
     fitting and it is not in the `Lexicon`, the way that it is handled
     depends on the setting of the `auto_delete` parameter. If
@@ -185,9 +188,9 @@ class TextLookup(_TextLookupMixin):
     TL has an :attr:`n_rows_` attribute which is only available after
     data has been passed to :meth:`partial_fit` or :meth:`fit`. It is
     the total number of rows of text seen in the original data and is
-    not necessarily the number of rows in the outputted data. TL also
-    has a :attr:`row_support_` attribute that is a boolean vector of
-    shape (n_rows, ) that indicates which rows of the original data were
+    not necessarily the total number of rows in the outputted data. TL
+    also has a :attr:`row_support_` attribute that is a boolean vector
+    that indicates which rows of the most-recently transformed data were
     kept during the transform process (True) and which were deleted
     (False). The only way that an entry could become False is if the
     `remove_empty_rows` parameter is True and a row becomes empty when
@@ -200,18 +203,18 @@ class TextLookup(_TextLookupMixin):
     update_lexicon : bool, default = False
         Whether to queue words that are not in the pybear :class:`Lexicon`
         for later addition to the `Lexicon`. This applies to both
-        autonomous and interactive modes. If False, TL will never put a
-        word in :attr:`LEXICON_ADDENDUM_` and will never prompt you with
-        the option.
+        autonomous and interactive modes. If False, TL will never put
+        a word in :attr:`LEXICON_ADDENDUM_` and will never prompt you
+        with the option.
     skip_numbers : bool, default = True
-        When True, TL will try to do Python float(word) on the word and,
-        if it can be cast to a float, TL will skip it and go to the next
-        word. If False, TL will handle it like any other word. There are
-        no numbers in the formal pybear `Lexicon` so TL will always flag
-        them and handle them autonomously or prompt the user for an
-        action. Since they are handled like any other word, it would be
-        possible to stage them for addition to your local copy of the
-        `Lexicon`.
+        When True, TL will try to do Python float(word) on the word
+        and, if it can be cast to a float, TL will skip it and go to
+        the next word. If False, TL will handle it like any other word.
+        There are no numbers in the formal pybear `Lexicon` so TL will
+        always flag them and handle them autonomously or prompt the user
+        for an action. Since they are handled like any other word, it
+        would be possible to stage them for addition to your local copy
+        of the `Lexicon`.
     auto_split : bool, default = True
         TL will first look if the word is in any of the holder objects
         for special instructions, then look to see if the word is in
@@ -219,60 +222,67 @@ class TextLookup(_TextLookupMixin):
         to `Lexicon`, auto-delete, or go into manual mode. This
         functionality is a last-ditch effort to see if a word is an
         erroneous compounding of 2 words that are in the `Lexicon`. If
-        `auto_split` is True, TL will iteratively split any word of 4 or
-        more characters from after the second character to before the
+        `auto_split` is True, TL will iteratively split any word of 4
+        or more characters from after the second character to before the
         second to last character and see if both halves are in the
-        `Lexicon`. When/if the first match is found, TL will remove the
-        original word, split it, and insert in the original place the 2
-        halves that were found to be in the `Lexicon`. If `auto_split`
-        is False, TL will skip this process and go straight to auto-add,
+        `Lexicon`. When/if the first match is found, TL will remove
+        the original word, split it, and insert in the original place
+        the 2 halves that were found to be in the `Lexicon`. If False,
+        TL will skip this process and go straight to auto-add,
         auto-delete, or manual mode.
     auto_add_to_lexicon : bool, default = False
-        `update_lexicon` must be True to use this parameter. Cannot
-        be True if `auto_delete` is True. When this parameter is
-        True, TL operates in 'auto-mode', where the user will not be
-        prompted for decisions. When TL encounters a word that is
-        not in the `Lexicon`, the word will silently be staged in
-        the `LEXICON_ADDENDUM_` attribute to be added to the `Lexicon`
-        later.
+        `update_lexicon` must be True to use this. Cannot be True
+        if `auto_delete` is True. When this parameter is True, TL
+        operates in 'auto-mode', where the user will not be prompted
+        for decisions. When TL encounters a word that is not in
+        the `Lexicon`, the word will silently be staged in the
+        `LEXICON_ADDENDUM_` attribute to be added to the `Lexicon` later.
     auto_delete : bool, default = False
-        If `update_lexicon` is True, then this cannot be set to True.
+        If `update_lexicon` is True then this cannot be set to True.
         When this parameter is True, TL operates in 'auto-mode', where
         the user will not be prompted for decisions. When TL encounters
         a word that is not in the `Lexicon`, the word will be silently
         deleted from the text body.
-    DELETE_ALWAYS : Sequence[str] | None, default = None
-        A list of words that will always be deleted by TL, even if they
-        are in the `Lexicon`. In both manual and auto modes, TL will
-        silently delete the word(s), no questions asked. What is passed
-        here becomes the seed for the :attr:`DELETE_ALWAYS_` attribute,
-        which may have more words added to it during run-time in manual
-        mode. Auto-mode will never add more words to this list.
-    REPLACE_ALWAYS : dict[str, str] | None, default = None
-        A dictionary with words expected to be in the text body as keys
-        and their respective single-word replacements as values. TL
-        will replace these words even if they are in the `Lexicon`.
-        For both auto and manual mode, TL will not prompt the user for
-        any more information, it will silently replace the word. What
-        is passed here becomes the seed for the :attr:`REPLACE_ALWAYS_`
-        attribute, which may have more word/replacement pairs added to
-        it during run-time in manual mode. Auto-mode will never add more
-        entries to this dictionary.
-    SKIP_ALWAYS : Sequence[str] | None, default = None
-        A list of words that will always be ignored by TL, even if
-        they are not in the `Lexicon`. For both auto and manual mode,
-        TL will not prompt the user for any more information, it will
+    DELETE_ALWAYS : Sequence[MatchType] | None, default = None
+        A list of words and/or full-word regex patterns that will always
+        be deleted by TL, even if they are in the `Lexicon`. For
+        both auto and manual modes, when a word in the text body is a
+        case-sensitive match against a string literal in this list, or
+        is a full-word match against a regex pattern in this list, TL
+        will not prompt the user for any more information, it will
+        silently delete the word. What is passed here becomes the seed
+        for the :attr:`DELETE_ALWAYS_` attribute, which may have more
+        words added to it during run-time in auto and manual modes.
+    REPLACE_ALWAYS : dict[MatchType, str] | None, default = None
+        A dictionary with words and/or full-word regex patterns as keys
+        and their respective single-word replacement strings as values.
+        For both auto and manual modes, when a word in the text body is
+        a case-sensitive match against a string literal key, or is a
+        full-word match against a regex pattern key, TL will not prompt
+        the user for any more information, it will silently make the
+        replacement. TL will replace these words even if they are in
+        the `Lexicon`. What is passed here becomes the seed for
+        the :attr:`REPLACE_ALWAYS_` attribute, which may have more
+        word/replacement pairs added to it during run-time in manual
+        mode. Auto-mode will never add more entries to this dictionary.
+    SKIP_ALWAYS : Sequence[MatchType] | None, default = None
+        A list of words and/or full-word regex patterns that will always
+        be ignored by TL, even if they are not in the `Lexicon`. For
+        both auto and manual modes, when a word in the text body is a
+        case-sensitive match against a string literal in this list, or
+        is a full-word match against a regex pattern in this list, TL
+        will not prompt the user for any more information, it will
         silently skip the word. What is passed here becomes the seed for
         the :attr:`SKIP_ALWAYS_` attribute, which may have more words
         added to it during run-time in manual mode. Auto-mode will only
-        a add entries to this list if `ignore_numbers` is True and TL
+        add entries to this list if `ignore_numbers` is True and TL
         finds a number during partial_fit / fit.
-    SPLIT_ALWAYS : dict[str, Sequence[str]] | None, default = None
-        A dictionary with words expected to be in the text body as keys
-        and their respective multi-word lists of replacements as values.
-        TL will remove the original word and insert these words into
-        the text body starting in its position even if the original
-        word is in the `Lexicon`. For both auto and manual mode, TL
+    SPLIT_ALWAYS : dict[MatchType, Sequence[str]] | None, default = None
+        A dictionary with words and/or full-word regex patterns as keys
+        and their respective multi-word lists of replacement strings as
+        values. TL will remove the original word and insert these words
+        into the text body starting in its position even if the original
+        word is in the `Lexicon`. For both auto and manual modes, TL
         will not prompt the user for any more information, it will
         silently split the word. What is passed here becomes the seed
         for the :attr:`SPLIT_ALWAYS_` attribute, which may have more
@@ -304,6 +314,31 @@ class TextLookup(_TextLookupMixin):
 
     Notes
     -----
+    When passing regex patterns to `DELETE_ALWAYS`, `REPLACE_ALWAYS`,
+    `SKIP_ALWAYS`, and `SPLIT_ALWAYS`, the regex patterns must be
+    designed to match full words in the text body and must be passed in
+    re.compile objects. Do not pass regex patterns as string literals,
+    you will not get the correct result. String literals must also be
+    designed to match full words in the text body. You do not need to
+    escape string literals.
+    If the same literal is passed to multiple 'ALWAYS' parameters, TL
+    will detect this conflict and raise an error. If a word in the text
+    body causes a conflict between a literal and a re.compile object or
+    between two re.compile objects within the same 'ALWAYS' parameter,
+    TL will raise an error. However, TL cannot detect conflicts between
+    re.compile objects across multiple 'ALWAYS' parameters, where a
+    word in a text body could possibly be indicated for two different
+    operations, such as SKIP and DELETE. TL will not resolve the conflict
+    but will simply perform whichever operation is matched first. The
+    order of match searching within TL is SKIP_ALWAYS, DELETE_ALWAYS,
+    REPLACE_ALWAYS, and finally SPLIT_ALWAYS. It is up to the user to
+    avoid these conflict conditions with careful regex pattern design.
+
+    **Type Aliases**
+
+    MatchType:
+        str | re.Pattern[str]
+
     PythonTypes:
         Sequence[Sequence[str]]
 
@@ -356,10 +391,10 @@ class TextLookup(_TextLookupMixin):
         auto_split:bool = True,
         auto_add_to_lexicon:bool = False,
         auto_delete:bool = False,
-        DELETE_ALWAYS:Sequence[str] | None = None,
-        REPLACE_ALWAYS:dict[str, str] | None = None,
-        SKIP_ALWAYS:Sequence[str] | None = None,
-        SPLIT_ALWAYS:dict[str, Sequence[str]] | None = None,
+        DELETE_ALWAYS:Sequence[str | re.Pattern[str]] | None = None,
+        REPLACE_ALWAYS:dict[str | re.Pattern[str], str] | None = None,
+        SKIP_ALWAYS:Sequence[str | re.Pattern[str]] | None = None,
+        SPLIT_ALWAYS:dict[str | re.Pattern[str], Sequence[str]] | None = None,
         remove_empty_rows:bool = False,
         verbose:bool = False
     ) -> None:
@@ -473,7 +508,7 @@ class TextLookup(_TextLookupMixin):
         X : XContainer
             The (possibly ragged) 2D container of text to have its
             contents cross-referenced against the pybear `Lexicon`.
-        y : Any, default = None
+        y : Any, default=None
             The target for the data. Always ignored.
 
         Returns
@@ -563,33 +598,68 @@ class TextLookup(_TextLookupMixin):
 
                 # -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
                 # short-circuit for things already known or learned in-situ
-                if _word in self._SKIP_ALWAYS:
-                    # this may have had words in it from the user at init
+
+                if _search_always_list('SKIP_ALWAYS', self._SKIP_ALWAYS, _word):
+                    # may have had user-given words/re.compiles at init.
                     if self.verbose:
                         print(f'\n*** ALWAYS SKIP *{_word}* ***\n')
                     continue
 
-                if _word in self._DELETE_ALWAYS:
-                    # this may have had words in it from the user at init
+                elif _search_always_list(
+                    'DELETE_ALWAYS', self._DELETE_ALWAYS, _word
+                ):
+                    # may have had user-given words/re.compiles at init.
                     if self.verbose:
                         print(f'\n*** ALWAYS DELETE *{_word}* ***\n')
                     continue
 
-                if _word in self._REPLACE_ALWAYS:
-                    # this may have had words in it from the user at init
+                elif _search_always_list(
+                    'REPLACE_ALWAYS', list(self._REPLACE_ALWAYS.keys()), _word
+                ):
+                    # may have had user-given words/re.compiles at init.
+                    # need to get the exact thing that matched _word out of
+                    # REPLACE_ALWAYS, to display the correct replacement.
+                    for item in self._REPLACE_ALWAYS:
+                        # check strings first, the order in _search_always_list
+                        if isinstance(item, str):
+                            if _word == item:
+                                _replacement = self._REPLACE_ALWAYS[_word]
+                                break
+                        elif isinstance(item, re.Pattern):
+                            if re.fullmatch(item, _word):
+                                _replacement = self._REPLACE_ALWAYS[item]
+                                break
+                        else:
+                            raise Exception
                     if self.verbose:
                         print(
                             f'\n*** ALWAYS REPLACE *{_word}* WITH '
-                            f'*{self._REPLACE_ALWAYS[_word]}* ***\n'
+                            f'*{_replacement}* ***\n'
                         )
                     continue
 
-                if _word in self._SPLIT_ALWAYS:
-                    # this may have had words in it from the user at init
+                elif _search_always_list(
+                    'SPLIT_ALWAYS', list(self._SPLIT_ALWAYS.keys()), _word
+                ):
+                    # may have had user-given words/re.compiles at init.
+                    # need to get the exact thing that matched _word out of
+                    # SPLIT_ALWAYS, to display the correct replacement.
+                    for item in self._SPLIT_ALWAYS:
+                        # check strings first, the order in _search_always_list
+                        if isinstance(item, str):
+                            if _word == item:
+                                _replacement = self._SPLIT_ALWAYS[_word]
+                                break
+                        elif isinstance(item, re.Pattern):
+                            if re.fullmatch(item, _word):
+                                _replacement = self._SPLIT_ALWAYS[item]
+                                break
+                        else:
+                            raise Exception
                     if self.verbose:
                         print(
                             f'\n*** ALWAYS SPLIT *{_word}* WITH '
-                            f'*{"*, *".join(self._SPLIT_ALWAYS[_word])}* ***\n'
+                            f'*{"*, *".join(_replacement)}* ***\n'
                         )
                     continue
 
@@ -858,26 +928,63 @@ class TextLookup(_TextLookupMixin):
                 _word = X_tr[_row_idx][_word_idx]
 
                 # -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
-                if _word in self._SKIP_ALWAYS:
-                    # this may have had words in it from the user at init
+                if _search_always_list('SKIP_ALWAYS', self._SKIP_ALWAYS, _word):
+                    # may have had user-given words/re.compiles at init.
                     continue
 
-                elif _word in self._DELETE_ALWAYS:
-                    # this may have had words in it from the user at init
+                elif _search_always_list(
+                    'DELETE_ALWAYS', self._DELETE_ALWAYS, _word
+                ):
+                    # may have had user-given words/re.compiles at init.
                     X_tr[_row_idx].pop(_word_idx)
                     continue
 
-                elif _word in self._REPLACE_ALWAYS:
-                    # this may have had words in it from the user at init
+                elif _search_always_list(
+                    'REPLACE_ALWAYS', list(self._REPLACE_ALWAYS.keys()), _word
+                ):
+                    # may have had user-given words/re.compiles at init.
+                    # need to get the exact thing that matched _word out of
+                    # REPLACE_ALWAYS, to pass the correct replacement
+                    # to _split_or_replace_handler.
+                    for item in self._REPLACE_ALWAYS:
+                        # check strings first, the order in _search_always_list
+                        if isinstance(item, str):
+                            if _word == item:
+                                _replacement = self._REPLACE_ALWAYS[_word]
+                                break
+                        elif isinstance(item, re.Pattern):
+                            if re.fullmatch(item, _word):
+                                _replacement = self._REPLACE_ALWAYS[item]
+                                break
+                        else:
+                            raise Exception
+
                     X_tr[_row_idx] = self._split_or_replace_handler(
-                        X_tr[_row_idx], _word_idx, [self._REPLACE_ALWAYS[_word]]
+                        X_tr[_row_idx], _word_idx, [_replacement]
                     )
                     continue
 
-                elif _word in self._SPLIT_ALWAYS:
-                    # this may have had words in it from the user at init
+                elif _search_always_list(
+                    'SPLIT_ALWAYS', list(self._SPLIT_ALWAYS.keys()), _word
+                ):
+                    # may have had user-given words/re.compiles at init.
+                    # need to get the exact thing that matched _word out of
+                    # SPLIT_ALWAYS, to pass the correct replacement
+                    # to _split_or_replace_handler.
+                    for item in self._SPLIT_ALWAYS:
+                        # check strings first, the order in _search_always_list
+                        if isinstance(item, str):
+                            if _word == item:
+                                _replacement = self._SPLIT_ALWAYS[_word]
+                                break
+                        elif isinstance(item, re.Pattern):
+                            if re.fullmatch(item, _word):
+                                _replacement = self._SPLIT_ALWAYS[item]
+                                break
+                        else:
+                            raise Exception
                     X_tr[_row_idx] = self._split_or_replace_handler(
-                        X_tr[_row_idx], _word_idx, self._SPLIT_ALWAYS[_word]
+                        X_tr[_row_idx], _word_idx, _replacement
                     )
                     # since the word_splitter functions require that
                     # all new words already be in KNOWN_WORDS, or are