| Current File : //usr/lib/python2.7/site-packages/paramiko/sftp_client.pyo |
�
=OXc @ s d d l m Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l m Z d d l
m Z d d l m
Z
d d l m Z m Z m Z d d l m Z m Z m Z m Z m Z m Z d d l m Z m Z m Z m Z m Z m Z m Z m! Z! m" Z" m# Z# m$ Z$ m% Z% m& Z& m' Z' m( Z( m) Z) m* Z* m+ Z+ m, Z, m- Z- m. Z. m/ Z/ m0 Z0 m1 Z1 m2 Z2 m3 Z3 m4 Z4 m5 Z5 m6 Z6 m7 Z7 d d l8 m9 Z9 d d
l: m; Z; d d l< m= Z= d d l> m? Z? d
� Z@ d ZA d e e? f d � � YZB d eB f d � � YZC d S( i����( t hexlifyN( t util( t Channel( t Message( t INFOt DEBUGt o777( t
bytestringt bt ut longt string_typest bytes_types( t BaseSFTPt CMD_OPENDIRt
CMD_HANDLEt SFTPErrort CMD_READDIRt CMD_NAMEt CMD_CLOSEt SFTP_FLAG_READt SFTP_FLAG_WRITEt SFTP_FLAG_CREATEt SFTP_FLAG_TRUNCt SFTP_FLAG_APPENDt SFTP_FLAG_EXCLt CMD_OPENt
CMD_REMOVEt
CMD_RENAMEt CMD_MKDIRt CMD_RMDIRt CMD_STATt CMD_ATTRSt CMD_LSTATt CMD_SYMLINKt CMD_SETSTATt CMD_READLINKt CMD_REALPATHt
CMD_STATUSt SFTP_OKt SFTP_EOFt SFTP_NO_SUCH_FILEt SFTP_PERMISSION_DENIED( t SFTPAttributes( t SSHException( t SFTPFile( t ClosingContextManagerc C sU y | j d � SWn= t t f k
rP y | j d � SWqQ t k
rL | SXn Xd S( s�
decode a string as ascii or utf8 if possible (as required by the sftp
protocol). if neither works, just return a byte string because the server
probably doesn't know the filename's encoding.
t asciis utf-8N( t encodet UnicodeErrort AttributeErrort decode( t s( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt _to_unicode- s
t /t
SFTPClientc B s� e Z d Z d � Z e d) d) d � � Z d � Z d � Z d � Z d d � Z
d d � Z d d d
� Z d d d
� Z
e
Z d � Z e Z d � Z e d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d) d � Z d � Z d � Z d d) e! d � Z" d) e! d � Z# d) d! � Z$ d) d" � Z% d# � Z& d$ � Z' d) d% � Z( d& � Z) d' � Z* d( � Z+ RS(* s�
SFTP client object.
Used to open an SFTP session across an open SSH `.Transport` and perform
remote file operations.
Instances of this class may be used as context managers.
c C s� t j | � | | _ t | _ d | _ t j � | _ d | _
t j � | _
t | � t k r� | j j � } t j | j � d � | _ | j � | _ n y | j � } Wn t k
r� t d � � n X| j t d | � d S( s�
Create an SFTP client from an existing `.Channel`. The channel
should already have requested the ``"sftp"`` subsystem.
An alternate way to create an SFTP client context is by using
`from_transport`.
:param .Channel sock: an open `.Channel` using the ``"sftp"`` subsystem
:raises SSHException: if there's an exception while negotiating
sftp
i s .sftps EOF during negotiations* Opened sftp connection (server version %d)N( R
t __init__t sockt Falset ultra_debugt request_numbert threadingt Lockt _lockt Nonet _cwdt weakreft WeakValueDictionaryt
_expectingt typeR t
get_transportR t
get_loggert get_log_channelt loggert get_hexdumpt
_send_versiont EOFErrorR, t _logR ( t selfR9 t transportt server_version( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyR8 G s
c C s? | j d | d | � } | d k r( d S| j d � | | � S( sP
Create an SFTP client channel from an open `.Transport`.
Setting the window and packet sizes might affect the transfer speed.
The default settings in the `.Transport` class are the same as in
OpenSSH and should work adequately for both files transfers and
interactive sessions.
:param .Transport t: an open `.Transport` which is already authenticated
:param int window_size:
optional window size for the `.SFTPClient` session.
:param int max_packet_size:
optional max packet size for the `.SFTPClient` session..
:return:
a new `.SFTPClient` object, referring to an sftp session (channel)
across the transport
.. versionchanged:: 1.15
Added the ``window_size`` and ``max_packet_size`` arguments.
t window_sizet max_packet_sizet sftpN( t open_sessionR@ t invoke_subsystem( t clst tRQ RR t chan( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt from_transporth s
c G s� t | t � r6 xl | D] } | j | | | � q WnH | j d d � } t t | � j | d | | j j � g t | � � d S( Nt %s %%s
[chan %s] ( t
isinstancet listRM t replacet superR7 R9 t get_name( RN t levelt msgt argst m( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyRM � s
c C s! | j t d � | j j � d S( sc
Close the SFTP session and its underlying channel.
.. versionadded:: 1.4
s sftp session closed.N( RM R R9 t close( RN ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyRd � s c C s | j S( s�
Return the underlying `.Channel` object for this SFTP session. This
might be useful for doing things like setting a timeout on the channel.
.. versionadded:: 1.7.1
( R9 ( RN ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt get_channel� s t .c C s# g | j | � D] } | j ^ q S( s�
Return a list containing the names of the entries in the given ``path``.
The list is in arbitrary order. It does not include the special
entries ``'.'`` and ``'..'`` even if they are present in the folder.
This method is meant to mirror ``os.listdir`` as closely as possible.
For a list of full `.SFTPAttributes` objects, see `listdir_attr`.
:param str path: path to list (defaults to ``'.'``)
( t listdir_attrt filename( RN t patht f( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt listdir� s c C sM | j | � } | j t d | � | j t | � \ } } | t k rV t d � � n | j � } g } x� t r8y | j t | � \ } } Wn t
k
r� Pn X| t k r� t d � � n | j � } xi t
| � D][ } | j � } | j � } t j | | | � }
| d k r� | d k r� | j |
� q� q� Wqk W| j t | � | S( s�
Return a list containing `.SFTPAttributes` objects corresponding to
files in the given ``path``. The list is in arbitrary order. It does
not include the special entries ``'.'`` and ``'..'`` even if they are
present in the folder.
The returned `.SFTPAttributes` objects will each have an additional
field: ``longname``, which may contain a formatted string of the file's
attributes, in unix format. The content of this string will probably
depend on the SFTP server implementation.
:param str path: path to list (defaults to ``'.'``)
:return: list of `.SFTPAttributes` objects
.. versionadded:: 1.2
s listdir(%r)s Expected handles Expected name responseRf s ..( t _adjust_cwdRM R t _requestR R R t
get_binaryt TrueR RL R t get_intt ranget get_textR+ t _from_msgt appendR ( RN Ri RW Ra t handlet filelistt countt iRh t longnamet attr( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyRg � s.
i2 c c s� | j | � } | j t d | � | j t | � \ } } | t k rV t d � � n | j � } t � } xQt r�y"x< t
| � D]. } | j t d � t | � } | j | � q� Wx� | D]� } | j � \ } } t | � } | j � }
| |
k r| t k r| j | � qn | j � } xa t
| � D]S } | j � } | j � }
t j | | |
� } | d k r1| d k r1| Vq1q1Wq� Wt � } Wqn t k
r�| j t | � d SXqn Wd S( s�
Generator version of `.listdir_attr`.
See the API docs for `.listdir_attr` for overall details.
This function adds one more kwarg on top of `.listdir_attr`:
``read_aheads``, an integer controlling how many
``SSH_FXP_READDIR`` requests are made to the server. The default of 50
should suffice for most file listings as each request/response cycle
may contain multiple files (dependant on server implementation.)
.. versionadded:: 1.15
s listdir(%r)s Expected handleRf s ..N( Rl RM R Rm R R R t
get_stringR\ Ro Rq t _async_requestRE R@ R Rt t _read_packetR Rp R& t _convert_statusRr R+ Rs RL R ( RN Ri t read_aheadsRW Ra Ru t numsRx t numt pkt_datat new_numRw Rh Ry Rz ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt listdir_iter� s>
t ri����c
C s` | j | � } | j t d | | f � d } d | k sG d | k rT | t O} n d | k sx d | k sx d | k r� | t O} n d | k r� | t t BO} n d | k r� | t t BO} n d | k r� | t t BO} n t � } | j
t | | | � \ } } | t k r t
d � � n | j � } | j t d | | t | � f � t | | | | � S(
sT
Open a file on the remote server. The arguments are the same as for
Python's built-in `python:file` (aka `python:open`). A file-like
object is returned, which closely mimics the behavior of a normal
Python file object, including the ability to be used as a context
manager.
The mode indicates how the file is to be opened: ``'r'`` for reading,
``'w'`` for writing (truncating an existing file), ``'a'`` for
appending, ``'r+'`` for reading/writing, ``'w+'`` for reading/writing
(truncating an existing file), ``'a+'`` for reading/appending. The
Python ``'b'`` flag is ignored, since SSH treats all files as binary.
The ``'U'`` flag is supported in a compatible way.
Since 1.5.2, an ``'x'`` flag indicates that the operation should only
succeed if the file was created and did not previously exist. This has
no direct mapping to Python's file flags, but is commonly known as the
``O_EXCL`` flag in posix.
The file will be buffered in standard Python style by default, but
can be altered with the ``bufsize`` parameter. ``0`` turns off
buffering, ``1`` uses line buffering, and any number greater than 1
(``>1``) uses that specific buffer size.
:param str filename: name of the file to open
:param str mode: mode (Python-style) to open in
:param int bufsize: desired buffering (-1 = default buffer size)
:return: an `.SFTPFile` object representing the open file
:raises IOError: if the file could not be opened.
s open(%r, %r)i R� t +t wt at xs Expected handles open(%r, %r) -> %s( Rl RM R R R R R R R R+ Rm R R R Rn R R- ( RN Rh t modet bufsizet imodet attrblockRW Ra Ru ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt open s(
$
#c C s7 | j | � } | j t d | � | j t | � d S( s
Remove the file at the given path. This only works on files; for
removing folders (directories), use `rmdir`.
:param str path: path (absolute or relative) of the file to remove
:raises IOError: if the path refers to a folder (directory)
s
remove(%r)N( Rl RM R Rm R ( RN Ri ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt removeQ s c C sO | j | � } | j | � } | j t d | | f � | j t | | � d S( s&
Rename a file or folder from ``oldpath`` to ``newpath``.
:param str oldpath: existing name of the file or folder
:param str newpath: new name for the file or folder
:raises IOError: if ``newpath`` is a folder, or something else goes
wrong
s rename(%r, %r)N( Rl RM R Rm R ( RN t oldpatht newpath( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt rename` s
c C sR | j | � } | j t d | | f � t � } | | _ | j t | | � d S( ss
Create a folder (directory) named ``path`` with numeric mode ``mode``.
The default mode is 0777 (octal). On some systems, mode is ignored.
Where it is used, the current umask value is first masked out.
:param str path: name of the folder to create
:param int mode: permissions (posix-style) for the newly-created folder
s
mkdir(%r, %r)N( Rl RM R R+ t st_modeRm R ( RN Ri R� Rz ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt mkdiro s
c C s7 | j | � } | j t d | � | j t | � d S( sj
Remove the folder named ``path``.
:param str path: name of the folder to remove
s rmdir(%r)N( Rl RM R Rm R ( RN Ri ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt rmdir~ s c C sc | j | � } | j t d | � | j t | � \ } } | t k rV t d � � n t j | � S( s8
Retrieve information about a file on the remote system. The return
value is an object whose attributes correspond to the attributes of
Python's ``stat`` structure as returned by ``os.stat``, except that it
contains fewer fields. An SFTP server may return as much or as little
info as it wants, so the results may vary from server to server.
Unlike a Python `python:stat` object, the result may not be accessed as
a tuple. This is mostly due to the author's slack factor.
The fields supported are: ``st_mode``, ``st_size``, ``st_uid``,
``st_gid``, ``st_atime``, and ``st_mtime``.
:param str path: the filename to stat
:return:
an `.SFTPAttributes` object containing attributes about the given
file
s stat(%r)s Expected attributes( Rl RM R Rm R R R R+ Rs ( RN Ri RW Ra ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt stat� s c C sc | j | � } | j t d | � | j t | � \ } } | t k rV t d � � n t j | � S( sZ
Retrieve information about a file on the remote system, without
following symbolic links (shortcuts). This otherwise behaves exactly
the same as `stat`.
:param str path: the filename to stat
:return:
an `.SFTPAttributes` object containing attributes about the given
file
s lstat(%r)s Expected attributes( Rl RM R Rm R! R R R+ Rs ( RN Ri RW Ra ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt lstat� s c C sL | j | � } | j t d | | f � t | � } | j t | | � d S( s�
Create a symbolic link (shortcut) of the ``source`` path at
``destination``.
:param str source: path of the original file
:param str dest: path of the newly created symlink
s symlink(%r, %r)N( Rl RM R R Rm R" ( RN t sourcet dest( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt symlink� s c C sR | j | � } | j t d | | f � t � } | | _ | j t | | � d S( s
Change the mode (permissions) of a file. The permissions are
unix-style and identical to those used by Python's `os.chmod`
function.
:param str path: path of the file to change the permissions of
:param int mode: new permissions
s
chmod(%r, %r)N( Rl RM R R+ R� Rm R# ( RN Ri R� Rz ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt chmod� s
c C s_ | j | � } | j t d | | | f � t � } | | | _ | _ | j t | | � d S( s�
Change the owner (``uid``) and group (``gid``) of a file. As with
Python's `os.chown` function, you must pass both arguments, so if you
only want to change one, use `stat` first to retrieve the current
owner and group.
:param str path: path of the file to change the owner and group of
:param int uid: new owner's uid
:param int gid: new group id
s chown(%r, %r, %r)N( Rl RM R R+ t st_uidt st_gidRm R# ( RN Ri t uidt gidRz ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt chown� s
c C s� | j | � } | d k r6 t j � t j � f } n | j t d | | f � t � } | \ | _ | _ | j t | | � d S( s�
Set the access and modified times of the file specified by ``path``. If
``times`` is ``None``, then the file's access and modified times are set
to the current time. Otherwise, ``times`` must be a 2-tuple of numbers,
of the form ``(atime, mtime)``, which is used to set the access and
modified times, respectively. This bizarre API is mimicked from Python
for the sake of consistency -- I apologize.
:param str path: path of the file to modify
:param tuple times:
``None`` or a tuple of (access time, modified time) in standard
internet epoch time (seconds since 01 January 1970 GMT)
s
utime(%r, %r)N(
Rl R@ t timeRM R R+ t st_atimet st_mtimeRm R# ( RN Ri t timesRz ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt utime� s c C sR | j | � } | j t d | | f � t � } | | _ | j t | | � d S( sL
Change the size of the file specified by ``path``. This usually
extends or shrinks the size of the file, just like the `~file.truncate`
method on Python file objects.
:param str path: path of the file to modify
:param size: the new size of the file
:type size: int or long
s truncate(%r, %r)N( Rl RM R R+ t st_sizeRm R# ( RN Ri t sizeRz ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt truncate� s
c C s� | j | � } | j t d | � | j t | � \ } } | t k rV t d � � n | j � } | d k rr d S| d k r� t d | � � n t | j
� � S( s
Return the target of a symbolic link (shortcut). You can use
`symlink` to create these. The result may be either an absolute or
relative pathname.
:param str path: path of the symbolic link file
:return: target path, as a `str`
s readlink(%r)s Expected name responsei i s Readlink returned %d resultsN( Rl RM R Rm R$ R R Rp R@ R5 R{ ( RN Ri RW Ra Rw ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt readlink s c C s� | j | � } | j t d | � | j t | � \ } } | t k rV t d � � n | j � } | d k r� t d | � � n | j � S( s�
Return the normalized path (on the server) of a given path. This
can be used to quickly resolve symbolic links or determine what the
server is considering to be the "current folder" (by passing ``'.'``
as ``path``).
:param str path: path to be normalized
:return: normalized form of the given path (as a `str`)
:raises IOError: if the path can't be resolved on the server
s
normalize(%r)s Expected name responsei s Realpath returned %d results( Rl RM R Rm R% R R Rp Rr ( RN Ri RW Ra Rw ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt normalize s c C s{ | d k r d | _ d St j | j | � j � s_ t t j d t j t j � | f � � n t
| j | � � | _ d S( s@
Change the "current directory" of this SFTP session. Since SFTP
doesn't really have the concept of a current working directory, this is
emulated by Paramiko. Once you use this method to set a working
directory, all operations on this `.SFTPClient` object will be relative
to that path. You can pass in ``None`` to stop using a current working
directory.
:param str path: new current working directory
:raises IOError: if the requested path doesn't exist on the server
.. versionadded:: 1.4
Ns %s: %s( R@ RA R� t S_ISDIRR� R t errnot ENOTDIRt ost strerrorR R� ( RN Ri ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt chdir2 s +c C s | j o t | j � S( s�
Return the "current working directory" for this SFTP session, as
emulated by Paramiko. If no directory has been set with `chdir`,
this method will return ``None``.
.. versionadded:: 1.4
( RA R ( RN ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt getcwdH s c C su d } xh t rp | j d � } | j | � | t | � 7} t | � d k rQ Pn | d k r | | | � q q W| S( Ni i � ( Ro t readt writet lenR@ ( RN t readert writert file_sizet callbackR� t data( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt _transfer_with_callbackS s
i c
C s� | j | d � �8 } | j t � | j d | d | d | d | � } Wd QX| r� | j | � } | j | k r� t d | j | f � � q� n t � } | S( s�
Copy the contents of an open file object (``fl``) to the SFTP server as
``remotepath``. Any exception raised by operations will be passed
through.
The SFTP operations use pipelining for speed.
:param fl: opened file or file-like object to copy
:param str remotepath: the destination path on the SFTP server
:param int file_size:
optional size parameter passed to callback. If none is specified,
size defaults to 0
:param callable callback:
optional callback function (form: ``func(int, int)``) that accepts
the bytes transferred so far and the total bytes to be transferred
(since 1.7.4)
:param bool confirm:
whether to do a stat() on the file afterwards to confirm the file
size (since 1.7.7)
:return:
an `.SFTPAttributes` object containing attributes about the given
file.
.. versionadded:: 1.10
t wbR� R� R� R� Ns size mismatch in put! %d != %d( t filet
set_pipelinedRo R� R� R� t IOErrorR+ ( RN t flt
remotepathR� R� t confirmt frR� R4 ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt putfo_ s
! c
C sG t j | � j } t | d � � } | j | | | | | � SWd QXd S( sb
Copy a local file (``localpath``) to the SFTP server as ``remotepath``.
Any exception raised by operations will be passed through. This
method is primarily provided as a convenience.
The SFTP operations use pipelining for speed.
:param str localpath: the local file to copy
:param str remotepath: the destination path on the SFTP server. Note
that the filename should be included. Only specifying a directory
may result in an error.
:param callable callback:
optional callback function (form: ``func(int, int)``) that accepts
the bytes transferred so far and the total bytes to be transferred
:param bool confirm:
whether to do a stat() on the file afterwards to confirm the file
size
:return: an `.SFTPAttributes` object containing attributes about the given file
.. versionadded:: 1.4
.. versionchanged:: 1.7.4
``callback`` and rich attribute return value added.
.. versionchanged:: 1.7.7
``confirm`` param added.
t rbN( R� R� R� R� R� ( RN t localpathR� R� R� R� R� ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt put� s c
C s` | j | � j } | j | d � �6 } | j | � | j d | d | d | d | � SWd QXt S( s�
Copy a remote file (``remotepath``) from the SFTP server and write to
an open file or file-like object, ``fl``. Any exception raised by
operations will be passed through. This method is primarily provided
as a convenience.
:param object remotepath: opened file or file-like object to copy to
:param str fl:
the destination path on the local host or open file object
:param callable callback:
optional callback function (form: ``func(int, int)``) that accepts
the bytes transferred so far and the total bytes to be transferred
:return: the `number <int>` of bytes written to the opened file object
.. versionadded:: 1.10
R� R� R� R� R� N( R� R� R� t prefetchR� R� ( RN R� R� R� R� R� ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt getfo� s
c C sk t | d � � } | j | | | � } Wd QXt j | � } | j | k rg t d | j | f � � n d S( s�
Copy a remote file (``remotepath``) from the SFTP server to the local
host as ``localpath``. Any exception raised by operations will be
passed through. This method is primarily provided as a convenience.
:param str remotepath: the remote file to copy
:param str localpath: the destination path on the local host
:param callable callback:
optional callback function (form: ``func(int, int)``) that accepts
the bytes transferred so far and the total bytes to be transferred
.. versionadded:: 1.4
.. versionchanged:: 1.7.4
Added the ``callback`` param
R� Ns size mismatch in get! %d != %d( R� R� R� R� R� R� ( RN R� R� R� R� R� R4 ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt get� s
c G s( | j t d � | | � } | j | � S( N( R| RE R@ t _read_response( RN RW t argR� ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyRm � s c G s# | j j � z� t � } | j | j � x� | D]� } t | t � rU | j | � q0 t | t � rt | j | � q0 t | t t
f � r� | j | � q0 t | t � r� | j
| � q0 t d | t | � f � � q0 W| j } | | j | <| j d 7_ Wd | j j � X| j | | � | S( Ns unknown type for %r type %ri ( R? t acquireR t add_intR< R[ R
t add_int64t intR R t
add_stringR+ t _packt ExceptionRE RD t releaset _send_packet( RN t fileobjRW R� Ra t itemR� ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyR| � s(
c C sJ xCt rEy | j � \ } } Wn) t k
rJ } t d t | � � � n Xt | � } | j � } | j j � zW | | j k r� | j
t d | f � | d k r� Pn w n | j | } | j | =Wd | j j
� X| | k r
| t k r | j | � n | | f S| t d � k r2| j | | | � n | d k r Pq q Wd S( Ns Server connection dropped: %ss Unexpected response #%d( NN( Ro R} RL R, t strR Rp R? R� RD RM R R@ R� R& R~ RE t _async_response( RN t waitforRW R� t eRa R� R� ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyR� � s4
c C s4 x- | | j j � k r/ | j � | j � q Wd S( N( RD t valuesR� t _check_exception( RN R� ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt _finish_responses s
c C s� | j � } | j � } | t k r( d S| t k rC t | � � nN | t k rd t t j | � � n- | t k r� t t j
| � � n t | � � d S( sU
Raises EOFError or IOError on error status; otherwise does nothing.
N( Rp Rr R' R( RL R) R� R� t ENOENTR* t EACCES( RN Ra t codet text( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyR~ s c C sk t | � } | j d k r | St | � rB | d d !t k rB | S| j t k r\ | j | S| j t | S( sr
Return an adjusted path if we're emulating a "current working
directory" for the server.
i i N( R RA R@ R� t b_slash( RN Ri ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyRl - s N(, t __name__t
__module__t __doc__R8 t classmethodR@ RY RM Rd Re Rk Rg R� R� R� R� t unlinkR� R R� R� R� R� R� R� R� R� R� R� R� R� R� R� Ro R� R� R� R� Rm R| R� R� R~ Rl ( ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyR7 > sN !
*A6
( ! t SFTPc B s e Z d Z RS( sA
An alias for `.SFTPClient` for backwards compatability.
( R� R� R� ( ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyR� = s (D t binasciiR R� R� R� R= R� RB t paramikoR t paramiko.channelR t paramiko.messageR t paramiko.commonR R R t paramiko.py3compatR R R R
R R t
paramiko.sftpR
R R R R R R R R R R R R R R R R R R R R! R" R# R$ R% R& R' R( R) R* t paramiko.sftp_attrR+ t paramiko.ssh_exceptionR, t paramiko.sftp_fileR- t
paramiko.utilR. R5 R� R7 R� ( ( ( s8 /usr/lib/python2.7/site-packages/paramiko/sftp_client.pyt <module> s. .� � � �