:param path_or_str_or_segments:
    :return:
    :rtype: cifparser.path.Path
424107
def make_path(*path_or_str_or_segments):
    
    if len(path_or_str_or_segments) == 0:
        return ROOT_PATH
    elif len(path_or_str_or_segments) == 1:
        single_item = path_or_str_or_segments[0]
        if isinstance(single_item, Path):
            return single_item
        if isinstance(single_item, str):
            try:
                return path_parser.parseString(single_item, True).asList()[0]
            except:
                raise ValueError()
        raise TypeError()
    else:
        segments = path_or_str_or_segments
        return sum(map(lambda x: make_path(x), segments), ROOT_PATH)
603200
def is_url(path):
        
        try:
            parse_result = urlparse(path)
            return all((parse_result.scheme, parse_result.netloc, parse_result.path))
        except ValueError:
            return False
423158
def get(path, headers: {}, query: {})
      @parent.get("/#{@segment}/#{path}".gsub(%r{/+}, '/'),
                  headers: @default_headers.merge(headers), query: query)
    end
582979
def _get_path(dict_, path):
    '''
    
    '''
    cur = dict_
    for part in path.split('/'):
        cur = cur[part]
    return cur
485440
def _rel(self, path):
        
        return os.path.relpath(
            str(path), self._parent).replace(os.path.sep, '/')
1374934
def CopyToPath(self):
    
    number_of_path_segments = len(self._path_segments)
    if number_of_path_segments == 0:
      return None

    strings = [self._path_segments[0]]
    number_of_path_segments -= 1
    for path_segment in self._path_segments[1:]:
      # Remove a trailing \ except for the last path segment.
      if path_segment.endswith('\\') and number_of_path_segments > 1:
        path_segment = path_segment[:-1]

      if ((path_segment.startswith('<') and path_segment.endswith('>')) or
          len(strings) == 1):
        strings.append(' {0:s}'.format(path_segment))
      elif path_segment.startswith('\\'):
        strings.append('{0:s}'.format(path_segment))
      else:
        strings.append('\\{0:s}'.format(path_segment))
      number_of_path_segments -= 1

    return ''.join(strings)
290948
def _get_page_from_path(self, path):
        
        from feincms.module.page.models import Page
        try:
            return Page.objects.best_match_for_path(path)
        except Page.DoesNotExist:
            return None
580469
def chkpath(path):
    
    if os.path.exists(path):
        return path
    else:
        msg = "{0} does not exist.".format(path)
        raise argparse.ArgumentTypeError(msg)
281686
def _path_to_str(self, path):
        
        inp = ''
        for arc in path:
            i = self.isyms.find(arc.ilabel)
            # Ignore \epsilon transitions both on input
            if i != fst.EPSILON:
                inp += i
        return inp
139824
def upath(path):
    
    if six.PY2 and not isinstance(path, six.text_type):
        return path.decode(fs_encoding)
    return path
1018045
def path(self, path):
        
        if os.path.isabs(path):
            return path
        return os.path.join(self.location, path)
943166
def path_to_url(path):
    # type: (Union[str, Text]) -> str
    
    path = os.path.normpath(os.path.abspath(path))
    url = urllib_parse.urljoin('file:', urllib_request.pathname2url(path))
    return url
981205
def relpath(self, path):
        
        return os.path.relpath(path, start=self.path)
614092
def reader(path_or_f):
    
    if hasattr(path_or_f, "read"):
        return path_or_f
    else:
        path = path_or_f

    path = normalize_path(path)
    _, extension = extract_extension(path)

    reader_func = FILE_READERS[extension]

    return reader_func(path)
704619
def _stringify_path(path_or_buffer):
    '''
    '''

    try:
        import pathlib
        _PATHLIB_INSTALLED = True
    except ImportError:
        _PATHLIB_INSTALLED = False

    if hasattr(path_or_buffer, '__fspath__'):
        return path_or_buffer.__fspath__()

    if _PATHLIB_INSTALLED and isinstance(path_or_buffer, pathlib.Path):
        return text_type(path_or_buffer)

    return path_or_buffer
291287
def join(self, path):
        

        return self.parse_uri(urlparse(os.path.join(str(self), path)), storage_args=self.storage_args)
720096
def is_paths(maybe_paths, marker='*'):
    
    return ((is_path(maybe_paths) and marker in maybe_paths) or  # Path str
            (is_path_obj(maybe_paths) and marker in maybe_paths.as_posix()) or
            (is_iterable(maybe_paths) and
             all(is_path(p) or is_ioinfo(p) for p in maybe_paths)))