FM / site-packages

/opt/imh-python/lib/python3.9/site-packages/

/opt/imh-python/lib/python3.9/site-packages

Name	Size	Mode	Actions
amqp/	-	0755	rm
amqp-5.3.1.dist-info/	-	0755	rm
apache_libcloud-3.1.0.dist-info/	-	0755	rm
appdirs-1.4.4.dist-info/	-	0755	rm
apscheduler/	-	0755	rm
APScheduler-3.11.0.dist-info/	-	0755	rm
arrow/	-	0755	rm
arrow-1.2.3.dist-info/	-	0755	rm
astroid/	-	0755	rm
astroid-3.3.9.dist-info/	-	0755	rm
asttokens/	-	0755	rm
asttokens-3.0.0.dist-info/	-	0755	rm
attr/	-	0755	rm
attrs/	-	0755	rm
attrs-25.3.0.dist-info/	-	0755	rm
autocommand/	-	0755	rm
autocommand-2.2.2.dist-info/	-	0755	rm
automat/	-	0755	rm
automat-25.4.16.dist-info/	-	0755	rm
backports/	-	0755	rm
backports.tarfile-1.2.0.dist-info/	-	0755	rm
bakauth/	-	0755	rm
bakauth-1.6.2.dist-info/	-	0755	rm
bcrypt/	-	0755	rm
bcrypt-3.2.2.dist-info/	-	0755	rm
billiard/	-	0755	rm
billiard-4.2.1.dist-info/	-	0755	rm
blessings/	-	0755	rm
blessings-1.7.dist-info/	-	0755	rm
boto3/	-	0755	rm
boto3-1.16.63.dist-info/	-	0755	rm
botocore/	-	0755	rm
botocore-1.19.63.dist-info/	-	0755	rm
celery/	-	0755	rm
celery-5.4.0.dist-info/	-	0755	rm
certifi/	-	0755	rm
certifi-2025.4.26.dist-info/	-	0755	rm
cffi/	-	0755	rm
cffi-1.17.1.dist-info/	-	0755	rm
chardet/	-	0755	rm
chardet-3.0.4.dist-info/	-	0755	rm
cheroot/	-	0755	rm
cheroot-10.0.1.dist-info/	-	0755	rm
cherrypy/	-	0755	rm
CherryPy-18.6.1.dist-info/	-	0755	rm
cinderclient/	-	0755	rm
click/	-	0755	rm
click-8.1.8.dist-info/	-	0755	rm
click_didyoumean/	-	0755	rm
click_didyoumean-0.3.1.dist-info/	-	0755	rm
click_plugins/	-	0755	rm
click_plugins-1.1.1.dist-info/	-	0755	rm
click_repl/	-	0755	rm
click_repl-0.3.0.dist-info/	-	0755	rm
constantly/	-	0755	rm
constantly-23.10.4.dist-info/	-	0755	rm
construct/	-	0755	rm
construct-2.10.70.dist-info/	-	0755	rm
cpapis/	-	0755	rm
cpapis-1.0.dist-info/	-	0755	rm
cproc/	-	0755	rm
cproc-1.0.dist-info/	-	0755	rm
croniter/	-	0755	rm
croniter-2.0.1.dist-info/	-	0755	rm
crossplane/	-	0755	rm
crossplane-0.5.8.dist-info/	-	0755	rm
Crypto/	-	0755	rm
Cryptodome/	-	0755	rm
cryptography/	-	0755	rm
cryptography-36.0.2.dist-info/	-	0755	rm
cwp/	-	0755	rm
cwp-0.1.2.dist-info/	-	0755	rm
dateutil/	-	0755	rm
debtcollector/	-	0755	rm
debtcollector-3.0.0.dist-info/	-	0755	rm
decorator-5.2.1.dist-info/	-	0755	rm
dill/	-	0755	rm
dill-0.4.0.dist-info/	-	0755	rm
distro/	-	0755	rm
distro-1.9.0.dist-info/	-	0755	rm
dns/	-	0755	rm
dnspython-2.7.0.dist-info/	-	0755	rm
dogpile/	-	0755	rm
dogpile_cache-1.4.0.dist-info/	-	0755	rm
exceptiongroup/	-	0755	rm
exceptiongroup-1.2.2.dist-info/	-	0755	rm
executing/	-	0755	rm
executing-2.2.0.dist-info/	-	0755	rm
fabric/	-	0755	rm
fab_classic-1.19.1.dist-info/	-	0755	rm
flask/	-	0755	rm
Flask-1.1.2.dist-info/	-	0755	rm
flask_apscheduler/	-	0755	rm
Flask_APScheduler-1.11.0.dist-info/	-	0755	rm
flask_redis/	-	0755	rm
flask_redis-0.4.0.dist-info/	-	0755	rm
flask_sqlalchemy/	-	0755	rm
Flask_SQLAlchemy-2.4.4.dist-info/	-	0755	rm
future/	-	0755	rm
future-1.0.0.dist-info/	-	0755	rm
gunicorn/	-	0755	rm
gunicorn-20.0.4.dist-info/	-	0755	rm
hyperlink/	-	0755	rm
hyperlink-21.0.0.dist-info/	-	0755	rm
idna/	-	0755	rm
idna-2.10.dist-info/	-	0755	rm
importlib_metadata/	-	0755	rm
importlib_metadata-4.13.0.dist-info/	-	0755	rm
incremental/	-	0755	rm
incremental-22.10.0.dist-info/	-	0755	rm
influxdb/	-	0755	rm
influxdb-5.3.2.dist-info/	-	0755	rm
IPython/	-	0755	rm
ipython-8.18.1.dist-info/	-	0755	rm
iso8601/	-	0755	rm
iso8601-2.1.0.dist-info/	-	0755	rm
isort/	-	0755	rm
isort-6.0.1.dist-info/	-	0755	rm
itsdangerous/	-	0755	rm
itsdangerous-1.1.0.dist-info/	-	0755	rm
jaraco/	-	0755	rm
jaraco.collections-5.1.0.dist-info/	-	0755	rm
jaraco.context-6.0.1.dist-info/	-	0755	rm
jaraco.functools-4.1.0.dist-info/	-	0755	rm
jaraco.text-4.0.0.dist-info/	-	0755	rm
jedi/	-	0755	rm
jedi-0.19.2.dist-info/	-	0755	rm
jinja2/	-	0755	rm
Jinja2-2.11.3.dist-info/	-	0755	rm
jmespath/	-	0755	rm
jmespath-0.10.0.dist-info/	-	0755	rm
jsonpatch-1.33.dist-info/	-	0755	rm
jsonpointer-3.0.0.dist-info/	-	0755	rm
keystoneauth1/	-	0755	rm
keystoneauth1-5.10.0.dist-info/	-	0755	rm
kombu/	-	0755	rm
kombu-5.5.3.dist-info/	-	0755	rm
ldap/	-	0755	rm
libcloud/	-	0755	rm
libfuturize/	-	0755	rm
libpasteurize/	-	0755	rm
markupsafe/	-	0755	rm
MarkupSafe-1.1.1.dist-info/	-	0755	rm
matplotlib_inline/	-	0755	rm
matplotlib_inline-0.1.7.dist-info/	-	0755	rm
mccabe-0.7.0.dist-info/	-	0755	rm
mdstat/	-	0755	rm
mdstat-1.0.4.dist-info/	-	0755	rm
meld3/	-	0755	rm
meld3-2.0.1.dist-info/	-	0755	rm
more_itertools/	-	0755	rm
more_itertools-10.7.0.dist-info/	-	0755	rm
msgpack/	-	0755	rm
msgpack-0.6.1.dist-info/	-	0755	rm
mtrlib/	-	0755	rm
mtrlib-1.2.0.dist-info/	-	0755	rm
munch/	-	0755	rm
munch-4.0.0.dist-info/	-	0755	rm
nacl/	-	0755	rm
netaddr/	-	0755	rm
netaddr-0.8.0.dist-info/	-	0755	rm
netifaces-0.10.9.dist-info/	-	0755	rm
netmiko/	-	0755	rm
netmiko-3.4.0.dist-info/	-	0755	rm
ntc_templates/	-	0755	rm
ntc_templates-7.8.0.dist-info/	-	0755	rm
numpy/	-	0755	rm
numpy-1.26.0.dist-info/	-	0755	rm
numpy.libs/	-	0755	rm
OpenSSL/	-	0755	rm
openstack/	-	0755	rm
openstacksdk-0.49.0.dist-info/	-	0755	rm
oslo.i18n-6.5.1.dist-info/	-	0755	rm
oslo.utils-7.1.0.dist-info/	-	0755	rm
oslo_i18n/	-	0755	rm
oslo_utils/	-	0755	rm
os_client_config/	-	0755	rm
os_client_config-2.1.0.dist-info/	-	0755	rm
os_service_types/	-	0755	rm
os_service_types-1.7.0.dist-info/	-	0755	rm
packaging/	-	0755	rm
packaging-25.0.dist-info/	-	0755	rm
paramiko/	-	0755	rm
paramiko-3.5.1.dist-info/	-	0755	rm
parso/	-	0755	rm
parso-0.8.4.dist-info/	-	0755	rm
past/	-	0755	rm
pbr/	-	0755	rm
pbr-6.1.1.dist-info/	-	0755	rm
pem/	-	0755	rm
pem-20.1.0.dist-info/	-	0755	rm
pexpect/	-	0755	rm
pexpect-4.9.0.dist-info/	-	0755	rm
picotui/	-	0755	rm
picotui-1.2.dist-info/	-	0755	rm
pip/	-	0755	rm
pip-25.1.1.dist-info/	-	0755	rm
pkg_resources/	-	0755	rm
platformdirs/	-	0755	rm
platformdirs-4.3.7.dist-info/	-	0755	rm
portend-3.2.0.dist-info/	-	0755	rm
pp_api/	-	0755	rm
pp_api-1.3.1.dist-info/	-	0755	rm
pr2modules/	-	0755	rm
prettytable-0.7.2.dist-info/	-	0755	rm
prometheus_client/	-	0755	rm
prometheus_client-0.14.1.dist-info/	-	0755	rm
prompt_toolkit/	-	0755	rm
prompt_toolkit-3.0.51.dist-info/	-	0755	rm
psutil/	-	0755	rm
psutil-5.7.3.dist-info/	-	0755	rm
psycopg2/	-	0755	rm
psycopg2-2.8.6.dist-info/	-	0755	rm
ptyprocess/	-	0755	rm
ptyprocess-0.7.0.dist-info/	-	0755	rm
pure_eval/	-	0755	rm
pure_eval-0.2.3.dist-info/	-	0755	rm
pyasn1/	-	0755	rm
pyasn1-0.6.1.dist-info/	-	0755	rm
pyasn1_modules/	-	0755	rm
pyasn1_modules-0.4.2.dist-info/	-	0755	rm
pycparser/	-	0755	rm
pycparser-2.22.dist-info/	-	0755	rm
pycryptodome-3.9.9.dist-info/	-	0755	rm
pycryptodomex-3.9.9.dist-info/	-	0755	rm
pyeapi/	-	0755	rm
pyeapi-0.8.4.dist-info/	-	0755	rm
pygit2/	-	0755	rm
pygit2-1.6.1.dist-info/	-	0755	rm
pygit2.libs/	-	0755	rm
pygments/	-	0755	rm
pygments-2.19.1.dist-info/	-	0755	rm
pygraph/	-	0755	rm
PyGraph-0.3.0.dist-info/	-	0755	rm
pyipmi/	-	0755	rm
pylint/	-	0755	rm
pylint-3.3.7.dist-info/	-	0755	rm
pymysql/	-	0755	rm
PyMySQL-1.0.3.dist-info/	-	0755	rm
PyNaCl-1.5.0.dist-info/	-	0755	rm
pynetbox/	-	0755	rm
pynetbox-6.5.0.dist-info/	-	0755	rm
pyOpenSSL-19.1.0.dist-info/	-	0755	rm
pyparsing/	-	0755	rm
pyparsing-3.2.3.dist-info/	-	0755	rm
pyroute2/	-	0755	rm
pyroute2-0.7.12.dist-info/	-	0755	rm
pyserial-3.5.dist-info/	-	0755	rm
pysparklines-1.4.dist-info/	-	0755	rm
python_cinderclient-7.1.0.dist-info/	-	0755	rm
python_crontab-2.7.1.dist-info/	-	0755	rm
python_dateutil-2.9.0.post0.dist-info/	-	0755	rm
python_ipmi-0.5.7.dist-info/	-	0755	rm
python_ldap-3.3.1.dist-info/	-	0755	rm
python_whois-0.7.3.dist-info/	-	0755	rm
pytz/	-	0755	rm
pytz-2025.2.dist-info/	-	0755	rm
pyudev/	-	0755	rm
pyudev-0.23.2.dist-info/	-	0755	rm
PyYAML-5.4.1.dist-info/	-	0755	rm
pyzmq-19.0.2.dist-info/	-	0755	rm
pyzmq.libs/	-	0755	rm
rads/	-	0755	rm
rads-4.1.0.dist-info/	-	0755	rm
redis/	-	0755	rm
redis-3.5.3.dist-info/	-	0755	rm
requests/	-	0755	rm
requests-2.24.0.dist-info/	-	0755	rm
requestsexceptions/	-	0755	rm
requestsexceptions-1.4.0.dist-info/	-	0755	rm
restic/	-	0755	rm
restic-1.3.5.dist-info/	-	0755	rm
s3transfer/	-	0755	rm
s3transfer-0.3.7.dist-info/	-	0755	rm
scp-0.15.0.dist-info/	-	0755	rm
serial/	-	0755	rm
service_identity/	-	0755	rm
service_identity-23.1.0.dist-info/	-	0755	rm
setproctitle-1.1.10.dist-info/	-	0755	rm
setuptools/	-	0755	rm
setuptools-57.0.0.dist-info/	-	0755	rm
simplejson/	-	0755	rm
simplejson-3.20.1.dist-info/	-	0755	rm
six-1.17.0.dist-info/	-	0755	rm
slapdtest/	-	0755	rm
sparkline/	-	0755	rm
sqlalchemy/	-	0755	rm
SQLAlchemy-1.3.24.dist-info/	-	0755	rm
stack_data/	-	0755	rm
stack_data-0.6.3.dist-info/	-	0755	rm
stevedore/	-	0755	rm
stevedore-5.4.1.dist-info/	-	0755	rm
tabulate-0.8.10.dist-info/	-	0755	rm
tailer/	-	0755	rm
tailer-0.4.1.dist-info/	-	0755	rm
tempora/	-	0755	rm
tempora-5.8.0.dist-info/	-	0755	rm
tenacity/	-	0755	rm
tenacity-9.1.2.dist-info/	-	0755	rm
test/	-	0755	rm
testdata/	-	0755	rm
tests/	-	0755	rm
textfsm/	-	0755	rm
textfsm-1.1.3.dist-info/	-	0755	rm
toml/	-	0755	rm
toml-0.10.2.dist-info/	-	0755	rm
tomli/	-	0755	rm
tomli-2.2.1.dist-info/	-	0755	rm
tomlkit/	-	0755	rm
tomlkit-0.13.2.dist-info/	-	0755	rm
tornado/	-	0755	rm
tornado-6.0.4.dist-info/	-	0755	rm
traitlets/	-	0755	rm
traitlets-5.14.3.dist-info/	-	0755	rm
twisted/	-	0755	rm
Twisted-22.4.0.dist-info/	-	0755	rm
typing_extensions-4.13.2.dist-info/	-	0755	rm
tzdata/	-	0755	rm
tzdata-2025.2.dist-info/	-	0755	rm
tzlocal/	-	0755	rm
tzlocal-5.3.1.dist-info/	-	0755	rm
untangle-1.1.1.dist-info/	-	0755	rm
urllib3/	-	0755	rm
urllib3-1.25.11.dist-info/	-	0755	rm
uWSGI-2.0.19.1.dist-info/	-	0755	rm
version_utils/	-	0755	rm
version_utils-0.3.2.dist-info/	-	0755	rm
vine/	-	0755	rm
vine-5.1.0.dist-info/	-	0755	rm
wcwidth/	-	0755	rm
wcwidth-0.2.13.dist-info/	-	0755	rm
werkzeug/	-	0755	rm
Werkzeug-2.0.3.dist-info/	-	0755	rm
wheel/	-	0755	rm
wheel-0.45.1.dist-info/	-	0755	rm
whois/	-	0755	rm
wrapt/	-	0755	rm
wrapt-1.17.2.dist-info/	-	0755	rm
yaml/	-	0755	rm
zc/	-	0755	rm
zc.lockfile-3.0.post1.dist-info/	-	0755	rm
zipp/	-	0755	rm
zipp-3.21.0.dist-info/	-	0755	rm
zmq/	-	0755	rm
zope/	-	0755	rm
zope.interface-7.2.dist-info/	-	0755	rm
_distutils_hack/	-	0755	rm
_yaml/	-	0755	rm
__pycache__/	-	0755	rm
appdirs.py	24720	0644	edit dl rm
cronlog.py	3773	0644	edit dl rm
crontab.py	46862	0644	edit dl rm
crontabs.py	4438	0644	edit dl rm
decorator.py	17067	0644	edit dl rm
distutils-precedence.pth	152	0644	edit dl rm
jsonpatch.py	29778	0644	edit dl rm
jsonpointer.py	10601	0644	edit dl rm
ldapurl.py	12525	0644	edit dl rm
ldif.py	20278	0644	edit dl rm
LICENSE	601	0644	edit dl rm
mccabe.py	10654	0644	edit dl rm
netifaces.cpython-39-x86_64-linux-gnu.so	24584	0755	edit dl rm
portend.py	6488	0644	edit dl rm
prettytable.py	54204	0644	edit dl rm
README.md	3180	0644	edit dl rm
README.txt	119	0644	edit dl rm
scp.py	22393	0644	edit dl rm
setproctitle.cpython-39-x86_64-linux-gnu.so	23952	0755	edit dl rm
six.py	34703	0644	edit dl rm
tabulate.py	73889	0644	edit dl rm
typing_extensions.py	172654	0644	edit dl rm
untangle.py	5535	0644	edit dl rm
uwsgidecorators.py	10392	0644	edit dl rm
zc.lockfile-3.0.post1-py3.9-nspkg.pth	519	0644	edit dl rm
zope.interface-7.2-py3.9-nspkg.pth	457	0644	edit dl rm
_cffi_backend.cpython-39-x86_64-linux-gnu.so	274096	0755	edit dl rm
_ldap.cpython-39-x86_64-linux-gnu.so	95632	0755	edit dl rm

Edit: /opt/imh-python/lib/python3.9/site-packages/scp.py (22393B)

# scp.py
# Copyright (C) 2008 James Bardin <j.bardin@gmail.com>

"""
Utilities for sending files over ssh using the scp1 protocol.
"""

__version__ = '0.15.0'

import locale
import os
import re
from socket import timeout as SocketTimeout

SCP_COMMAND = b'scp'

PATH_TYPES = (str, bytes)

try:
    import pathlib
except ImportError:
    pathlib = None
else:
    PATH_TYPES += pathlib.PurePath,
try:
    PATH_TYPES += unicode,
except NameError:
    pass

try:
    from typing import IO, TYPE_CHECKING, AnyStr, Callable, Iterable, Optional, Tuple, Union

if TYPE_CHECKING:
        import paramiko.transport

# this is some magic to make sure pyright doesn't get too confused with pathlib potentially being a nullable variable
    import pathlib
    PurePath = pathlib.PurePath

PathTypes = Union[str, bytes, PurePath]
except ImportError:
    pass

# this is quote from the shlex module, added in py3.3
_find_unsafe = re.compile(br'[^\w@%+=:,./~-]').search

def _sh_quote(s):
    """Return a shell-escaped version of the string `s`."""
    if not s:
        return b""
    if _find_unsafe(s) is None:
        return s

# use single quotes, and put single quotes into double quotes
    # the string $'b is then quoted as '$'"'"'b'
    return b"'" + s.replace(b"'", b"'\"'\"'") + b"'"

# Unicode conversion functions; assume UTF-8

def asbytes(s):
    """Turns unicode into bytes, if needed.

Assumes UTF-8.
    """
    if isinstance(s, bytes):
        return s
    elif pathlib and isinstance(s, pathlib.PurePath):
        return bytes(s)
    else:
        return s.encode('utf-8')

def asunicode(s):
    """Turns bytes into unicode, if needed.

Uses UTF-8.
    """
    if isinstance(s, bytes):
        return s.decode('utf-8', 'replace')
    else:
        return s

# os.path.sep is unicode on Python 3, no matter the platform
bytes_sep = asbytes(os.path.sep)

# Unicode conversion function for Windows
# Used to convert local paths if the local machine is Windows

def asunicode_win(s):
    """Turns bytes into unicode, if needed.
    """
    if isinstance(s, bytes):
        return s.decode(locale.getpreferredencoding())
    else:
        return s

class SCPClient(object):
    """
    An scp1 implementation, compatible with openssh scp.
    Raises SCPException for all transport related errors. Local filesystem
    and OS errors pass through.

Main public methods are .put and .get
    The get method is controlled by the remote scp instance, and behaves
    accordingly. This means that symlinks are resolved, and the transfer is
    halted after too many levels of symlinks are detected.
    The put method uses os.walk for recursion, and sends files accordingly.
    Since scp doesn't support symlinks, we send file symlinks as the file
    (matching scp behaviour), but we make no attempt at symlinked directories.
    """
    def __init__(self, transport, buff_size=16384, socket_timeout=10.0,
                 progress=None, progress4=None, sanitize=_sh_quote, limit_bw=None):
        # type: (paramiko.transport.Transport, int, float, Optional[Callable[[bytes, int, int], None]], Optional[Callable[[bytes, int, int, Tuple[str, int]], None]], Callable[[bytes], bytes]) -> None
        """
        Create an scp1 client.

@param transport: an existing paramiko L{Transport}
        @type transport: L{Transport}
        @param buff_size: size of the scp send buffer.
        @type buff_size: int
        @param socket_timeout: channel socket timeout in seconds
        @type socket_timeout: float
        @param progress: callback - called with (filename, size, sent) during
            transfers
        @param progress4: callback - called with (filename, size, sent, peername)
            during transfers. peername is a tuple contains (IP, PORT)
        @param sanitize: function - called with filename, should return
            safe or escaped string. Uses _sh_quote by default. Set to ``False``
            to disable.
        @type progress: function(string, int, int, tuple)
        @limit_bw: limits the bandwidth used on the connection in Kbps. Must be integer positive.
            the default value None does not limit the bandwidth.
        @type limit_bw: Optional[int]
        """
        self.transport = transport
        self.buff_size = buff_size
        self.socket_timeout = socket_timeout
        self.channel = None
        self.preserve_times = False
        if progress is not None and progress4 is not None:
            raise TypeError("You may only set one of progress, progress4")
        elif progress4 is not None:
            self._progress = progress4
        elif progress is not None:
            self._progress = lambda *a: progress(*a[:3])
        else:
            self._progress = None
        self._recv_dir = b''
        self._depth = 0
        self._rename = False
        self._utime = None
        if sanitize is False:
            self.sanitize = lambda x: x
        else:
            self.sanitize = sanitize
        self._dirtimes = {}
        self.peername = self.transport.getpeername()
        self.scp_command = SCP_COMMAND
        if limit_bw:
            self.scp_command += b' -l %d' % limit_bw

def __enter__(self):
        self.channel = self._open()
        return self

def __exit__(self, type, value, traceback):
        self.close()

def put(self, files, remote_path=b'.',
            recursive=False, preserve_times=False):
        # type: (Union[PathTypes, Iterable[PathTypes]], Union[str, bytes], bool, bool) -> None
        """
        Transfer files and directories to remote host.

@param files: A single path, or a list of paths to be transferred.
            recursive must be True to transfer directories.
        @type files: string OR list of strings
        @param remote_path: path in which to receive the files on the remote
            host. defaults to '.'
        @type remote_path: str
        @param recursive: transfer files and directories recursively
        @type recursive: bool
        @param preserve_times: preserve mtime and atime of transferred files
            and directories.
        @type preserve_times: bool
        """
        self.preserve_times = preserve_times
        self.channel = self._open()
        self._pushed = 0
        self.channel.settimeout(self.socket_timeout)
        scp_command = self.scp_command + b' ' + (b'-t ', b'-r -t ')[recursive]
        self.channel.exec_command(scp_command +
                                  self.sanitize(asbytes(remote_path)))
        self._recv_confirm()

if isinstance(files, PATH_TYPES):
            files = [files]
        else:
            files = list(files)

if recursive:
            self._send_recursive(files)
        else:
            self._send_files(files)

self.close()

def putfo(self, fl, remote_path, mode='0644', size=None):
        # type: (IO[AnyStr], Union[str, bytes], Union[str, bytes], Optional[int]) -> None
        """
        Transfer file-like object to remote host.

@param fl: opened file or file-like object to copy
        @type fl: file-like object
        @param remote_path: full destination path
        @type remote_path: str
        @param mode: permissions (posix-style) for the uploaded file
        @type mode: str
        @param size: size of the file in bytes. If ``None``, the size will be
            computed using `seek()` and `tell()`.
        """
        if size is None:
            pos = fl.tell()
            fl.seek(0, os.SEEK_END)  # Seek to end
            size = fl.tell() - pos
            fl.seek(pos, os.SEEK_SET)  # Seek back

self.channel = self._open()
        self.channel.settimeout(self.socket_timeout)
        self.channel.exec_command(self.scp_command + b' -t ' +
                                  self.sanitize(asbytes(remote_path)))
        self._recv_confirm()
        self._send_file(fl, remote_path, mode, size=size)
        self.close()

def get(self, remote_path, local_path='',
            recursive=False, preserve_times=False):
        # type: (PathTypes, Union[str, bytes], bool, bool) -> None
        """
        Transfer files and directories from remote host to localhost.

@param remote_path: path to retrieve from remote host. Note that
            wildcards will be escaped unless you changed the `sanitize`
            function.
        @type remote_path: str
        @param local_path: path in which to receive files locally
        @type local_path: str
        @param recursive: transfer files and directories recursively
        @type recursive: bool
        @param preserve_times: preserve mtime and atime of transferred files
            and directories.
        @type preserve_times: bool
        """
        if isinstance(remote_path, PATH_TYPES):
            remote_path = [remote_path]
        else:
            remote_path = list(remote_path)
        remote_path = [self.sanitize(asbytes(r)) for r in remote_path]
        self._recv_dir = local_path or os.getcwd()
        self._depth = 0
        self._rename = (len(remote_path) == 1 and
                        not os.path.isdir(os.path.abspath(local_path)))
        if len(remote_path) > 1:
            if not os.path.exists(self._recv_dir):
                raise SCPException("Local path '%s' does not exist" %
                                   asunicode(self._recv_dir))
            elif not os.path.isdir(self._recv_dir):
                raise SCPException("Local path '%s' is not a directory" %
                                   asunicode(self._recv_dir))
        rcsv = (b'', b' -r')[recursive]
        prsv = (b'', b' -p')[preserve_times]
        self.channel = self._open()
        self._pushed = 0
        self.channel.settimeout(self.socket_timeout)
        self.channel.exec_command(self.scp_command +
                                  rcsv +
                                  prsv +
                                  b" -f " +
                                  b' '.join(remote_path))
        self._recv_all()
        self.close()

def _open(self):
        """open a scp channel"""
        if self.channel is None or self.channel.closed:
            self.channel = self.transport.open_session()

return self.channel

def close(self):
        """close scp channel"""
        if self.channel is not None:
            self.channel.close()
            self.channel = None

def _read_stats(self, name):
        """return just the file stats needed for scp"""
        if os.name == 'nt':
            name = asunicode(name)
        stats = os.stat(name)
        mode = oct(stats.st_mode)[-4:]
        size = stats.st_size
        atime = int(stats.st_atime)
        mtime = int(stats.st_mtime)
        return (mode, size, mtime, atime)

def _send_files(self, files):
        for name in files:
            (mode, size, mtime, atime) = self._read_stats(name)
            if self.preserve_times:
                self._send_time(mtime, atime)
            fl = open(name, 'rb')
            try:
                self._send_file(fl, name, mode, size)
            finally:
                fl.close()

def _send_file(self, fl, name, mode, size):
        basename = asbytes(os.path.basename(name))
        # The protocol can't handle \n in the filename.
        # Quote them as the control sequence \^J for now,
        # which is how openssh handles it.
        self.channel.sendall(("C%s %d " % (mode, size)).encode('ascii') +
                             basename.replace(b'\n', b'\\^J') + b"\n")
        self._recv_confirm()
        file_pos = 0
        if self._progress:
            if size == 0:
                # avoid divide-by-zero
                self._progress(basename, 1, 1, self.peername)
            else:
                self._progress(basename, size, 0, self.peername)
        buff_size = self.buff_size
        chan = self.channel
        while file_pos < size:
            chan.sendall(fl.read(buff_size))
            file_pos = fl.tell()
            if self._progress:
                self._progress(basename, size, file_pos, self.peername)
        chan.sendall('\x00')
        self._recv_confirm()

def _chdir(self, from_dir, to_dir):
        # Pop until we're one level up from our next push.
        # Push *once* into to_dir.
        # This is dependent on the depth-first traversal from os.walk

# add path.sep to each when checking the prefix, so we can use
        # path.dirname after
        common = os.path.commonprefix([from_dir + bytes_sep,
                                       to_dir + bytes_sep])
        # now take the dirname, since commonprefix is character based,
        # and we either have a separator, or a partial name
        common = os.path.dirname(common)
        cur_dir = from_dir.rstrip(bytes_sep)
        while cur_dir != common:
            cur_dir = os.path.split(cur_dir)[0]
            self._send_popd()
        # now we're in our common base directory, so on
        self._send_pushd(to_dir)

def _send_recursive(self, files):
        for base in files:
            base = asbytes(base)
            if not os.path.isdir(base):
                # filename mixed into the bunch
                self._send_files([base])
                continue
            last_dir = asbytes(base)
            for root, dirs, fls in os.walk(base):
                if not asbytes(root).endswith(b'/'):
                    self._chdir(last_dir, asbytes(root))
                self._send_files([os.path.join(root, f) for f in fls])
                last_dir = asbytes(root)
            # back out of the directory
            while self._pushed > 0:
                self._send_popd()

def _send_pushd(self, directory):
        (mode, size, mtime, atime) = self._read_stats(directory)
        basename = asbytes(os.path.basename(directory))
        if self.preserve_times:
            self._send_time(mtime, atime)
        self.channel.sendall(('D%s 0 ' % mode).encode('ascii') +
                             basename.replace(b'\n', b'\\^J') + b'\n')
        self._recv_confirm()
        self._pushed += 1

def _send_popd(self):
        self.channel.sendall('E\n')
        self._recv_confirm()
        self._pushed -= 1

def _send_time(self, mtime, atime):
        self.channel.sendall(('T%d 0 %d 0\n' % (mtime, atime)).encode('ascii'))
        self._recv_confirm()

def _recv_confirm(self):
        # read scp response
        msg = b''
        try:
            msg = self.channel.recv(512)
        except SocketTimeout:
            raise SCPException('Timeout waiting for scp response')
        # slice off the first byte, so this compare will work in py2 and py3
        if msg and msg[0:1] == b'\x00':
            return
        elif msg and msg[0:1] == b'\x01':
            raise SCPException(asunicode(msg[1:]))
        elif self.channel.recv_stderr_ready():
            msg = self.channel.recv_stderr(512)
            raise SCPException(asunicode(msg))
        elif not msg:
            raise SCPException('No response from server')
        else:
            raise SCPException('Invalid response from server', msg)

def _recv_all(self):
        # loop over scp commands, and receive as necessary
        command = {b'C': self._recv_file,
                   b'T': self._set_time,
                   b'D': self._recv_pushd,
                   b'E': self._recv_popd}
        while not self.channel.closed:
            # wait for command as long as we're open
            self.channel.sendall('\x00')
            msg = self.channel.recv(1024)
            if not msg:  # chan closed while receiving
                break
            assert msg[-1:] == b'\n'
            msg = msg[:-1]
            code = msg[0:1]
            if code not in command:
                raise SCPException(asunicode(msg[1:]))
            command[code](msg[1:])
        # directory times can't be set until we're done writing files
        self._set_dirtimes()

def _set_time(self, cmd):
        try:
            times = cmd.split(b' ')
            mtime = int(times[0])
            atime = int(times[2]) or mtime
        except:
            self.channel.send(b'\x01')
            raise SCPException('Bad time format')
        # save for later
        self._utime = (atime, mtime)

def _recv_file(self, cmd):
        chan = self.channel
        parts = cmd.strip().split(b' ', 2)

try:
            mode = int(parts[0], 8)
            size = int(parts[1])
            if self._rename:
                path = self._recv_dir
                self._rename = False
            elif os.name == 'nt':
                name = parts[2].decode('utf-8')
                assert not os.path.isabs(name)
                path = os.path.join(asunicode_win(self._recv_dir), name)
            else:
                name = parts[2]
                assert not os.path.isabs(name)
                path = os.path.join(asbytes(self._recv_dir), name)
        except:
            chan.send('\x01')
            chan.close()
            raise SCPException('Bad file format')

try:
            file_hdl = open(path, 'wb')
        except IOError as e:
            chan.send(b'\x01' + str(e).encode('utf-8'))
            chan.close()
            raise

if self._progress:
            if size == 0:
                # avoid divide-by-zero
                self._progress(path, 1, 1, self.peername)
            else:
                self._progress(path, size, 0, self.peername)
        buff_size = self.buff_size
        pos = 0
        chan.send(b'\x00')
        try:
            while pos < size:
                # we have to make sure we don't read the final byte
                if size - pos <= buff_size:
                    buff_size = size - pos
                data = chan.recv(buff_size)
                if not data:
                    raise SCPException("Underlying channel was closed")
                file_hdl.write(data)
                pos = file_hdl.tell()
                if self._progress:
                    self._progress(path, size, pos, self.peername)
            msg = chan.recv(512)
            if msg and msg[0:1] != b'\x00':
                raise SCPException(asunicode(msg[1:]))

file_hdl.truncate()
            os.utime(path, self._utime)
            self._utime = None
            os.chmod(path, mode)
            # should we notify the other end?
        except SocketTimeout:
            chan.close()
            raise SCPException('Error receiving, socket.timeout')
        finally:
            file_hdl.close()
        # '\x00' confirmation sent in _recv_all

def _recv_pushd(self, cmd):
        parts = cmd.split(b' ', 2)
        try:
            mode = int(parts[0], 8)
            if self._rename:
                path = self._recv_dir
                self._rename = False
            elif os.name == 'nt':
                name = parts[2].decode('utf-8')
                assert not os.path.isabs(name)
                path = os.path.join(asunicode_win(self._recv_dir), name)
                self._depth += 1
            else:
                name = parts[2]
                assert not os.path.isabs(name)
                path = os.path.join(asbytes(self._recv_dir), name)
                self._depth += 1
        except:
            self.channel.send(b'\x01')
            raise SCPException('Bad directory format')
        try:
            if not os.path.exists(path):
                os.mkdir(path, mode)
            elif os.path.isdir(path):
                os.chmod(path, mode)
            else:
                raise SCPException('%s: Not a directory' % path)
            self._dirtimes[path] = (self._utime)
            self._utime = None
            self._recv_dir = path
        except (OSError, SCPException) as e:
            self.channel.send(b'\x01' + asbytes(str(e)))
            raise

def _recv_popd(self, *cmd):
        if self._depth > 0:
            self._depth -= 1
            self._recv_dir = os.path.split(self._recv_dir)[0]

def _set_dirtimes(self):
        try:
            for d in self._dirtimes:
                os.utime(d, self._dirtimes[d])
        finally:
            self._dirtimes = {}

class SCPException(Exception):
    """SCP exception class"""
    pass

def put(transport, files, remote_path=b'.',
        recursive=False, preserve_times=False):
    # type: (paramiko.transport.Transport, Union[PathTypes, Iterable[PathTypes]], Union[str, bytes], bool, bool) -> None
    """
    Transfer files and directories to remote host.

This is a convenience function that creates a SCPClient from the given
    transport and closes it at the end, useful for one-off transfers.

def get(transport, remote_path, local_path='',
        recursive=False, preserve_times=False):
    # type: (paramiko.transport.Transport, PathTypes, Union[str, bytes], bool, bool) -> None
    """
    Transfer files and directories from remote host to localhost.

This is a convenience function that creates a SCPClient from the given
    transport and closes it at the end, useful for one-off transfers.

@param transport: an paramiko L{Transport}
    @type transport: L{Transport}
    @param remote_path: path to retrieve from remote host. Note that wildcards
        will be escaped unless you changed the `sanitize` function.
    @type remote_path: str
    @param local_path: path in which to receive files locally
    @type local_path: str
    @param recursive: transfer files and directories recursively
    @type recursive: bool
    @param preserve_times: preserve mtime and atime of transferred files
        and directories.
    @type preserve_times: bool
    """
    with SCPClient(transport) as client:
        client.get(remote_path, local_path, recursive, preserve_times)

cmd: