text: import regex
  from django.core.exceptions import ValidationError
  from django.utils.deconstruct import deconstructible
  from django.utils.functional import SimpleLazyObject
  from django.utils.translation import gettext_lazy as _
  
  
  def _lazy_re_compile(regex_value, flags=0):
      """Lazily compile a regex with flags."""
  
      def _compile():
          # Compile the regex if it was not passed pre-compiled.
          if isinstance(regex_value, str):
              return regex.compile(regex_value, flags)
          else:
              assert not flags, "flags must be empty if regex is passed pre-compiled"
              return regex_value
  
      return SimpleLazyObject(_compile)
  
  
  @deconstructible
  class UnicodeRegexValidator:
      """
      Amazingly the standard python re regex library does not correctly match valid
      unicode word characters https://bugs.python.org/issue12731 ...
  
      This is an exact copy of Django's Regex validator, but instead using the swap in
      replacement regex library instead of re, which does handle unicode correctly!
      """
  
      regex = ""
      message = _("Enter a valid value.")
      code = "invalid"
      inverse_match = False
      flags = 0
  
      def __init__(
          self, regex_value=None, message=None, code=None, inverse_match=None, flags=None
      ):
          if regex_value is not None:
              self.regex_value = regex_value
          if message is not None:
              self.message = message
          if code is not None:
              self.code = code
          if inverse_match is not None:
              self.inverse_match = inverse_match
          if flags is not None:
              self.flags = flags
          if self.flags and not isinstance(self.regex_value, str):
              raise TypeError(
                  "If the flags are set, regex must be a regular expression string."
              )
  
          self.regex_value = _lazy_re_compile(self.regex_value, self.flags)
  
      def __call__(self, value):
          """
          Validate that the input contains (or does *not* contain, if
          inverse_match is True) a match for the regular expression.
          """
          regex_matches = self.regex_value.search(str(value))
          invalid_input = regex_matches if self.inverse_match else not regex_matches
          if invalid_input:
              raise ValidationError(self.message, code=self.code)
  
      def __eq__(self, other):
          return (
              isinstance(other, UnicodeRegexValidator)
              and self.regex_value.pattern == other.regex_value.pattern
              and self.regex_value.flags == other.regex_value.flags
              and (self.message == other.message)
              and (self.code == other.code)
              and (self.inverse_match == other.inverse_match)
          )
  