code: def _get_handle(
      path_or_buf,
      mode,
      encoding=None,
      compression=None,
      memory_map=False,
      is_text=True,
  ):
      """
      Get file handle for given path/buffer and mode.
  
      Parameters
      ----------
      path_or_buf :
          a path (str) or buffer
      mode : str
          mode to open path_or_buf with
      encoding : str or None
      compression : {'infer', 'gzip', 'bz2', 'zip', 'xz', None}, default None
          If 'infer' and `filepath_or_buffer` is path-like, then detect
          compression from the following extensions: '.gz', '.bz2', '.zip',
          or '.xz' (otherwise no compression).
      memory_map : boolean, default False
          See parsers._parser_params for more information.
      is_text : boolean, default True
          whether file/buffer is in text format (csv, json, etc.), or in binary
          mode (pickle, etc.)
  
      Returns
      -------
      f : file-like
          A file-like object
      handles : list of file-like objects
          A list of file-like object that were opened in this function.
      """
      try:
          from s3fs import S3File
  
          need_text_wrapping = (BytesIO, S3File)
      except ImportError:
          need_text_wrapping = (BytesIO,)
  
      handles = list()
      f = path_or_buf
  
      # Convert pathlib.Path/py.path.local or string
      path_or_buf = _stringify_path(path_or_buf)
      is_path = isinstance(path_or_buf, compat.string_types)
  
      if is_path:
          compression = _infer_compression(path_or_buf, compression)
  
      if compression:
          if compat.PY2 and not is_path and encoding:
              msg = "compression with encoding is not yet supported in Python 2"
              raise ValueError(msg)
  
          # GZ Compression
          if compression == "gzip":
              import gzip
  
              if is_path:
                  f = gzip.open(path_or_buf, mode)
              else:
                  f = gzip.GzipFile(fileobj=path_or_buf)
  
          # BZ Compression
          elif compression == "bz2":
              import bz2
  
              if is_path:
                  f = bz2.BZ2File(path_or_buf, mode)
              elif compat.PY2:
                  # Python 2's bz2 module can't take file objects, so have to
                  # run through decompress manually
                  f = StringIO(bz2.decompress(path_or_buf.read()))
                  path_or_buf.close()
              else:
                  f = bz2.BZ2File(path_or_buf)
  
          # ZIP Compression
          elif compression == "zip":
              zf = BytesZipFile(path_or_buf, mode)
              # Ensure the container is closed as well.
              handles.append(zf)
              if zf.mode == "w":
                  f = zf
              elif zf.mode == "r":
                  zip_names = zf.namelist()
                  if len(zip_names) == 1:
                      f = zf.open(zip_names.pop())
                  elif len(zip_names) == 0:
                      raise ValueError(
                          "Zero files found in ZIP file {}".format(
                              path_or_buf
                          )
                      )
                  else:
                      raise ValueError(
                          "Multiple files found in ZIP file."
                          " Only one file per ZIP: {}".format(zip_names)
                      )
  
          # XZ Compression
          elif compression == "xz":
              lzma = compat.import_lzma()
              f = lzma.LZMAFile(path_or_buf, mode)
  
          # Unrecognized Compression
          else:
              msg = "Unrecognized compression type: {}".format(
                  compression
              )
              raise ValueError(msg)
  
          handles.append(f)
  
      elif is_path:
          if compat.PY2:
              # Python 2
              mode = "wb" if mode == "w" else mode
              f = open(path_or_buf, mode)
          elif encoding:
              # Python 3 and encoding
              f = open(path_or_buf, mode, encoding=encoding, newline="")
          elif is_text:
              # Python 3 and no explicit encoding
              f = open(path_or_buf, mode, errors="replace", newline="")
          else:
              # Python 3 and binary mode
              f = open(path_or_buf, mode)
          handles.append(f)
  
      # in Python 3, convert BytesIO or fileobjects passed with an encoding
      if (
          compat.PY3
          and is_text
          and (compression or isinstance(f, need_text_wrapping))
      ):
          from io import TextIOWrapper
  
          f = TextIOWrapper(f, encoding=encoding, newline="")
          handles.append(f)
  
      if memory_map and hasattr(f, "fileno"):
          try:
              g = MMapWrapper(f)
              f.close()
              f = g
          except Exception:
              # we catch any errors that may have occurred
              # because that is consistent with the lower-level
              # functionality of the C engine (pd.read_csv), so
              # leave the file handler as is then
              pass
  
      return f, handles
  
imports: import codecs
  from contextlib import closing, contextmanager
  import csv
  import mmap
  import os
  import zipfile
  import pandas.compat
  from pandas.compat import BytesIO, StringIO, string_types, text_type
  from pandas.errors import AbstractMethodError, DtypeWarning, EmptyDataError, ParserError, ParserWarning
  from pandas.core.dtypes.common import is_file_like, is_number
  from pandas.io.formats.printing import pprint_thing
label_desc: Use image node_id 10 for calling a global function with example usage: _get_handle(path_or_buf, mode, encoding, compression, memory_map, is_text) and returns: f,  handles