code: def s3_path_join(*args, with_end_slash: bool = False):
      """Returns the arguments joined by a slash ("/"), similar to ``os.path.join()`` (on Unix).
  
      Behavior of this function:
      - If the first argument is "s3://", then that is preserved.
      - The output by default will have no slashes at the beginning or end. There is one exception
          (see `with_end_slash`). For example, `s3_path_join("/foo", "bar/")` will yield
          `"foo/bar"` and `s3_path_join("foo", "bar", with_end_slash=True)` will yield `"foo/bar/"`
      - Any repeat slashes will be removed in the output (except for "s3://" if provided at the
          beginning). For example, `s3_path_join("s3://", "//foo/", "/bar///baz")` will yield
          `"s3://foo/bar/baz"`.
      - Empty or None arguments will be skipped. For example
          `s3_path_join("foo", "", None, "bar")` will yield `"foo/bar"`
  
      Alternatives to this function that are NOT recommended for S3 paths:
      - `os.path.join(...)` will have different behavior on Unix machines vs non-Unix machines
      - `pathlib.PurePosixPath(...)` will apply potentially unintended simplification of single
          dots (".") and root directories. (for example
          `pathlib.PurePosixPath("foo", "/bar/./", "baz")` would yield `"/bar/baz"`)
      - `"{}/{}/{}".format(...)` and similar may result in unintended repeat slashes
  
      Args:
          *args: The strings to join with a slash.
          with_end_slash (bool): (default: False) If true and if the path is not empty, appends a "/"
              to the end of the path
  
      Returns:
          str: The joined string, without a slash at the end unless with_end_slash is True.
      """
      delimiter = "/"
  
      non_empty_args = list(
          filter(lambda item: item is not None and item != "", args)
      )
  
      merged_path = ""
      for index, path in enumerate(non_empty_args):
          if (
              index == 0
              or (merged_path and merged_path[-1] == delimiter)
              or (path and path[0] == delimiter)
          ):
              # dont need to add an extra slash because either this is the beginning of the string,
              # or one (or more) slash already exists
              merged_path += path
          else:
              merged_path += delimiter + path
  
      if (
          with_end_slash
          and merged_path
          and merged_path[-1] != delimiter
      ):
          merged_path += delimiter
  
      # At this point, merged_path may include slashes at the beginning and/or end. And some of the
      # provided args may have had duplicate slashes inside or at the ends.
      # For backwards compatibility reasons, these need to be filtered out (done below). In the
      # future, if there is a desire to support multiple slashes for S3 paths throughout the SDK,
      # one option is to create a new optional argument (or a new function) that only executes the
      # logic above.
      filtered_path = merged_path
  
      # remove duplicate slashes
      if filtered_path:
  
          def duplicate_delimiter_remover(sequence, next_char):
              if sequence[-1] == delimiter and next_char == delimiter:
                  return sequence
              return sequence + next_char
  
          if filtered_path.startswith("s3://"):
              filtered_path = reduce(
                  duplicate_delimiter_remover,
                  filtered_path[5:],
                  filtered_path[:5],
              )
          else:
              filtered_path = reduce(
                  duplicate_delimiter_remover, filtered_path
              )
  
      # remove beginning slashes
      filtered_path = filtered_path.lstrip(delimiter)
  
      # remove end slashes
      if not with_end_slash and filtered_path != "s3://":
          filtered_path = filtered_path.rstrip(delimiter)
  
      return filtered_path
  
imports: from __future__ import print_function, absolute_import
  import logging
  from functools import reduce
  from typing import Optional
  from six.moves.urllib.parse import urlparse
label_desc: Use image node_id 2 for calling a global function with example usage: s3_path_join() and returns: filtered_path, unknown, sequence