class_docstr: The :class:`RegexPattern` class is an implementation of a pattern
  using regular expressions.
docstr: Initializes the :class:`RegexPattern` instance.
  
  *pattern* (:class:`unicode`, :class:`bytes`, :class:`re.RegexObject`,
  or :data:`None`) is the pattern to compile into a regular
  expression.
  
  *include* (:class:`bool` or :data:`None`) must be :data:`None`
  unless *pattern* is a precompiled regular expression (:class:`re.RegexObject`)
  in which case it is whether matched files should be included
  (:data:`True`), excluded (:data:`False`), or is a null operation
  (:data:`None`).
  
          .. NOTE:: Subclasses do not need to support the *include*
             parameter.
code: def __init__(self, pattern, include=None):
      """
      Initializes the :class:`RegexPattern` instance.
  
      *pattern* (:class:`unicode`, :class:`bytes`, :class:`re.RegexObject`,
      or :data:`None`) is the pattern to compile into a regular
      expression.
  
      *include* (:class:`bool` or :data:`None`) must be :data:`None`
      unless *pattern* is a precompiled regular expression (:class:`re.RegexObject`)
      in which case it is whether matched files should be included
      (:data:`True`), excluded (:data:`False`), or is a null operation
      (:data:`None`).
  
              .. NOTE:: Subclasses do not need to support the *include*
                 parameter.
      """
  
      self.regex = None
      """
  		*regex* (:class:`re.RegexObject`) is the regular expression for the
  		pattern.
  		"""
  
      if isinstance(pattern, (unicode, bytes)):
          assert (
              include is None
          ), "include:{!r} must be null when pattern:{!r} is a string.".format(
              include, pattern
          )
          regex, include = self.pattern_to_regex(pattern)
          # NOTE: Make sure to allow a null regular expression to be
          # returned for a null-operation.
          if include is not None:
              regex = re.compile(regex)
  
      elif pattern is not None and hasattr(pattern, "match"):
          # Assume pattern is a precompiled regular expression.
          # - NOTE: Used specified *include*.
          regex = pattern
  
      elif pattern is None:
          # NOTE: Make sure to allow a null pattern to be passed for a
          # null-operation.
          assert (
              include is None
          ), "include:{!r} must be null when pattern:{!r} is null.".format(
              include, pattern
          )
  
      else:
          raise TypeError(
              "pattern:{!r} is not a string, RegexObject, or None.".format(
                  pattern
              )
          )
  
      super(RegexPattern, self).__init__(include)
      self.regex = regex
  
file_path: ray/python/ray/_private/thirdparty/pathspec/pattern.py
imports: import re
  from .compat import unicode
label_desc: Use image node_id 1 to create a new RegexPattern object from inherited base classes: Pattern with example: obj = RegexPattern(pattern, include)