docs: def _parse_path(self, path):
          """Parse ``path`` into segments.
  
          Paths must start with a WORD (i.e., a top level Django setting
          name). Path segments are separated by dots. Compound path
          segments (i.e., a name with a dot in it) can be grouped inside
          parentheses.
  
          Examples::
  
              >>> settings = Settings()
              >>> settings._parse_path('WORD')
              ['WORD']
              >>> settings._parse_path('WORD.x')
              ['WORD', 'x']
              >>> settings._parse_path('WORD.(x)')
              ['WORD', 'x']
              >>> settings._parse_path('WORD.(x.y)')
              ['WORD', 'x.y']
              >>> settings._parse_path('WORD.(x.y).z')
              ['WORD', 'x.y', 'z']
              >>> settings._parse_path('WORD.0.z')
              ['WORD', 0, 'z']
              >>> settings._parse_path('WORD.(0).z')
              ['WORD', '0', 'z']
              >>> settings._parse_path('WORD.(0)X.z')
              ['WORD', '0X', 'z']
  
          An example of where compound names are actually useful is in
          logger settings::
  
              LOGGING.loggers.(package.module).handlers = ["console"]
              LOGGING.loggers.(package.module).level = "DEBUG"
  
          Paths may also contain interpolation groups. Dotted names in
          these groups will not be split (so there's no need to group them
          inside parentheses)::
  
              >>> settings = Settings()
              >>> settings._parse_path('WORD.{{x}}')
              ['WORD', '{{x}}']
              >>> settings._parse_path('WORD.{{x.y}}')
              ['WORD', '{{x.y}}']
              >>> settings._parse_path('WORD.{{x.y.z}}XYZ')
              ['WORD', '{{x.y.z}}XYZ']
  
          Interpolation groups *can* be wrapped in parentheses, but doing
          so is redundant::
  
              >>> settings._parse_path('WORD.({{x.y.z}}XYZ)')
              ['WORD', '{{x.y.z}}XYZ']
  
          Any segment that A) looks like an int and B) does *not* contain
          a (...) or {{...}} group will be converted to an int. Segments
          that start with a leading "0" followed by other digits will not
          be converted.
  
          """
          if not path:
              raise ValueError('path cannot be empty')
  
          segments = []
          path_iter = zip(iter(path), chain(path[1:], (None,)))
          if six.PY2:
              # zip() returns a list on Python 2
              path_iter = iter(path_iter)
          convert_name = self._convert_name
          current_segment = []
          current_segment_contains_group = False
  
          def append_segment():
              segment = ''.join(current_segment)
              if not current_segment_contains_group:
                  segment = convert_name(segment)
              segments.append(segment)
              del current_segment[:]
  
          for c, d in path_iter:
              if c == '.':
                  append_segment()
                  current_segment_contains_group = False
              elif c == '(':
                  nested = 0
                  for c, d in path_iter:
                      current_segment.append(c)
                      if c == '(':
                          nested += 1
                      elif c == ')':
                          if nested:
                              nested -= 1
                          else:
                              current_segment.pop()  # Remove the closing paren
                              current_segment_contains_group = True
                              break
                  else:
                      raise ValueError('Unclosed (...) in %s' % path)
              elif c == '{' and d == '{':
                  current_segment_contains_group = True
                  current_segment.append(c)
                  for c, d in path_iter:
                      current_segment.append(c)
                      if c == '}' and d == '}':
                          current_segment_contains_group = True
                          break
                  else:
                      raise ValueError('Unclosed {{...}} in %s' % path)
              else:
                  current_segment.append(c)
  
          if current_segment:
              append_segment()
  
          return segments