code: def NormalizePath(path, sep="/"):
    
    if not path:
      return sep
    path = SmartUnicode(path)
  
    path_list = path.split(sep)
  
    # This is a relative path and the first element is . or ..
    if path_list[0] in [".", "..", ""]:
      path_list.pop(0)
  
    # Deliberately begin at index 1 to preserve a single leading /
    i = 0
  
    while True:
      list_len = len(path_list)
  
      # We begin at the last known good position so we never iterate over path
      # elements which are already examined
      for i in range(i, len(path_list)):
        # Remove /./ form
        if path_list[i] == "." or not path_list[i]:
          path_list.pop(i)
          break
  
        # Remove /../ form
        elif path_list[i] == "..":
          path_list.pop(i)
          # Anchor at the top level
          if (i == 1 and path_list[0]) or i > 1:
            i -= 1
            path_list.pop(i)
          break
  
      # If we didnt alter the path so far we can quit
      if len(path_list) == list_len:
        return sep + sep.join(path_list)
docs: A sane implementation of os.path.normpath.
  
    The standard implementation treats leading / and // as different leading to
    incorrect normal forms.
  
    NOTE: Its ok to use a relative path here (without leading /) but any /../ will
    still be removed anchoring the path at the top level (e.g. foo/../../../../bar
    => bar).
  
    Args:
       path: The path to normalize.
       sep: Separator used.
  
    Returns:
       A normalized path. In this context normalized means that all input paths
       that would result in the system opening the same physical file will produce
       the same normalized path.