docs: def get(self, remote, local=None, preserve_mode=True):
          """
          Download a file from the current connection to the local filesystem.
  
          :param str remote:
              Remote file to download.
  
              May be absolute, or relative to the remote working directory.
  
              .. note::
                  Most SFTP servers set the remote working directory to the
                  connecting user's home directory, and (unlike most shells) do
                  *not* expand tildes (``~``).
  
                  For example, instead of saying ``get("~/tmp/archive.tgz")``,
                  say ``get("tmp/archive.tgz")``.
  
          :param local:
              Local path to store downloaded file in, or a file-like object.
  
              **If None or another 'falsey'/empty value is given** (the default),
              the remote file is downloaded to the current working directory (as
              seen by `os.getcwd`) using its remote filename.
  
              **If a string is given**, it should be a path to a local directory
              or file and is subject to similar behavior as that seen by common
              Unix utilities or OpenSSH's ``sftp`` or ``scp`` tools.
  
              For example, if the local path is a directory, the remote path's
              base filename will be added onto it (so ``get('foo/bar/file.txt',
              '/tmp/')`` would result in creation or overwriting of
              ``/tmp/file.txt``).
  
              .. note::
                  When dealing with nonexistent file paths, normal Python file
                  handling concerns come into play - for example, a ``local``
                  path containing non-leaf directories which do not exist, will
                  typically result in an `OSError`.
  
              **If a file-like object is given**, the contents of the remote file
              are simply written into it.
  
          :param bool preserve_mode:
              Whether to `os.chmod` the local file so it matches the remote
              file's mode (default: ``True``).
  
          :returns: A `.Result` object.
  
          .. versionadded:: 2.0
          """
          # TODO: how does this API change if we want to implement
          # remote-to-remote file transfer? (Is that even realistic?)
          # TODO: handle v1's string interpolation bits, especially the default
          # one, or at least think about how that would work re: split between
          # single and multiple server targets.
          # TODO: callback support
          # TODO: how best to allow changing the behavior/semantics of
          # remote/local (e.g. users might want 'safer' behavior that complains
          # instead of overwriting existing files) - this likely ties into the
          # "how to handle recursive/rsync" and "how to handle scp" questions
  
          # Massage remote path
          if not remote:
              raise ValueError("Remote path must not be empty!")
          orig_remote = remote
          remote = posixpath.join(
              self.sftp.getcwd() or self.sftp.normalize("."), remote
          )
  
          # Massage local path:
          # - handle file-ness
          # - if path, fill with remote name if empty, & make absolute
          orig_local = local
          is_file_like = hasattr(local, "write") and callable(local.write)
          if not local:
              local = posixpath.basename(remote)
          if not is_file_like:
              local = os.path.abspath(local)
  
          # Run Paramiko-level .get() (side-effects only. womp.)
          # TODO: push some of the path handling into Paramiko; it should be
          # responsible for dealing with path cleaning etc.
          # TODO: probably preserve warning message from v1 when overwriting
          # existing files. Use logging for that obviously.
          #
          # If local appears to be a file-like object, use sftp.getfo, not get
          if is_file_like:
              self.sftp.getfo(remotepath=remote, fl=local)
          else:
              self.sftp.get(remotepath=remote, localpath=local)
              # Set mode to same as remote end
              # TODO: Push this down into SFTPClient sometime (requires backwards
              # incompat release.)
              if preserve_mode:
                  remote_mode = self.sftp.stat(remote).st_mode
                  mode = stat.S_IMODE(remote_mode)
                  os.chmod(local, mode)
          # Return something useful
          return Result(
              orig_remote=orig_remote,
              remote=remote,
              orig_local=orig_local,
              local=local,
              connection=self.connection,
          )