Ii> II ' ' -4   ((dY L ""9dkk:  &   s!;D*D D0D0/D0c4[URR55Vs/sHo3SU::dM UPM nn[U5S:XagUR SS9 USupVXV-U::agXV-X-:agUR XV-X-U- U- 5$s snf)NrFc US$Nr)xs r*5SFTPFile._data_in_prefetch_requests..vsQqTr,)keyT)listr!valueslensort_data_in_prefetch_requests)r'offsetsizerIk buf_offsetbuf_sizes r*rR#SFTPFile._data_in_prefetch_requestspsD2299;< " u  F *  FM 1..  !6=:#=#H   s BBcURR5Vs/sH o"U::dM UPM nn[U5S:Xag[U5nX- nU[URU5:agU$s snf)z if a block of data is present in the prefetch buffers, at the given offset, return the offset of the relevant prefetch buffer. otherwise, return None. this guarantees nothing about the number of bytes collected in the prefetch buffer so far. rN)r keysrPmax)r'rSirUindexrVs r*_data_in_prefetch_buffers"SFTPFile._data_in_prefetch_bufferssq++002 B216kQ2 B q6Q;A^ T0078 8  Cs A0A0cURUR5nUbOOUR(dUR(aO,URR 5 UR 5 MnUcSUlgURUnURU URU- nUS:aUSUURU'X4SnU[U5:a#X1SURURU-'USUnU$)z read data out of the prefetch buffer, if possible. if the data isn't in the buffer, return None. otherwise, behaves like a normal read. NFr) r^_realposrr9r_read_response_check_exceptionrr rP)r'rTrSprefetchrVs r*_read_prefetchSFTPFile._read_prefetchs33DMMBF!""dll II $ $ &  ! ! # > %D &&v.    ']]V+ >*2;J*?D   ' ,H #h- 8@D    4 5Hr,cX[XR5nUR(aURU5nUbU$URR [ UR[UR5[U55up4U[:wa [S5eUR5$)N Expected data)minMAX_REQUEST_SIZErrerr?r rrraintr r get_string)r'rTdatatmsgs r*_readSFTPFile._reads4../   &&t,D ## dkk5#7T  =O, ,~~r,c [[U5UR5nURR [ S5[ UR[UR5USU5nURRU5 UR(aB[UR5S:aURRR5(a[UR5(ahURR5nURR!U5upVU[":wa [%S5e[UR5(aMhU$)NdzExpected status)rirPrjrr=r>r rrrar&appendrsock recv_readypopleftrbrr )r'rmchunksftp_async_requestreqrnros r*_writeSFTPFile._writesCIt445!YY55 J  KK $-- %L   ,-~~  Oc !diinn&?&?&A&Adjj//jj((*11#6 ?#$566 djj//  r,cNURRRU5 g)a Set a timeout on read/write operations on the underlying socket or ssh `.Channel`. :param float timeout: seconds to wait for a pending read/write operation before raising ``socket.timeout``, or ``None`` for no timeout .. seealso:: `.Channel.settimeout` N)rru settimeout)r'timeouts r*r~SFTPFile.settimeouts !!'*r,cJURRR5$)z Returns the timeout in seconds (as a `float`) associated with the socket or ssh `.Channel` used for this file. .. seealso:: `.Channel.gettimeout` )rru gettimeoutr2s r*rSFTPFile.gettimeoutsyy~~((**r,cNURRRU5 g)z Set blocking or non-blocking mode on the underiying socket or ssh `.Channel`. :param int blocking: 0 to set non-blocking mode; non-0 to set blocking mode. .. seealso:: `.Channel.setblocking` N)rru setblocking)r'blockings r*rSFTPFile.setblockings ""8,r,cg)z Check if the file supports random access. :return: `True` if the file supports random access. If `False`, :meth:`seek` will raise an exception TrHr2s r*seekableSFTPFile.seekablesr,c(UR5 X R:XaU=UlUlOUX R:Xa'U=RU- slURUlOUR 5U-=UlUl[ 5Ulg)z@ Set the file's current position. See `file.seek` for details. N)flushSEEK_SETra_posSEEK_CUR _get_sizebytes_rbuffer)r'rSwhences r*seek SFTPFile.seeksk ]] "(. .DMDI }} $ II I IIDM(,(86(A ADMDI r,cURR[UR5upU[:wa [ S5e[ R"U5$)z Retrieve information about this file from the remote system. This is exactly like `.SFTPClient.stat`, except that it operates on an already-open file. :returns: an `.SFTPAttributes` object containing attributes about this file. zExpected attributes)rr?rrrr r _from_msg)r'rnros r*stat SFTPFile.statsD##It{{; >12 2'',,r,cURR[SR[ UR 5U55 [ 5nXlURR[UR U5 g)z Change the mode (permissions) of this file. The permissions are unix-style and identical to those used by Python's `os.chmod` function. :param int mode: new permissions zchmod({}, {!r})N) rr:rr;rrrst_moder?r)r'r(attrs r*chmodSFTPFile.chmod sY  $++GDKK,@$G   <d;r,cURR[SR[ UR 5X55 [ 5nXsUlUlURR[UR U5 g)a Change the owner (``uid``) and group (``gid``) of this 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 int uid: new owner's uid :param int gid: new group id zchown({}, {!r}, {!r})N) rr:rr;rrrst_uidst_gidr?r)r'uidgidrs r*chownSFTPFile.chown/sb   # * *74;;+? J #&  T[ <d;r,clUc*[R"5[R"54nURR[SR [ UR 5U55 [5nUuUlUl URR[UR U5 g)a Set the access and modified times of this file. 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 tuple times: ``None`` or a tuple of (access time, modified time) in standard internet epoch time (seconds since 01 January 1970 GMT) Nzutime({}, {!r})) timerr:rr;rrrst_atimest_mtimer?r)r'timesrs r*utimeSFTPFile.utimeAs} =YY[$))+.E  $++GDKK,@%H ',$ t} <d;r,cURR[SR[ UR 5U55 [ 5nXlURR[UR U5 g)z Change the size of this file. This usually extends or shrinks the size of the file, just like the ``truncate()`` method on Python file objects. :param size: the new size of the file ztruncate({}, {!r})N) rr:rr;rrrst_sizer?r)r'rTrs r*truncateSFTPFile.truncateWsY  '..wt{{/CTJ   <d;r,c URR[SURU[ U5[ U5U5upVUR 5 UR 5 UR 5nU$)a Ask the server for a hash of a section of this file. This can be used to verify a successful upload or download, or for various rsync-like operations. The file is hashed from ``offset``, for ``length`` bytes. If ``length`` is 0, the remainder of the file is hashed. Thus, if both ``offset`` and ``length`` are zero, the entire file is hashed. Normally, ``block_size`` will be 0 (the default), and this method will return a byte string representing the requested hash (for example, a string of length 16 for MD5, or 20 for SHA-1). If a non-zero ``block_size`` is given, each chunk of the file (from ``offset`` to ``offset + length``) of ``block_size`` bytes is computed as a separate hash. The hash results are all concatenated and returned as a single string. For example, ``check('sha1', 0, 1024, 512)`` will return a string of length 40. The first 20 bytes will be the SHA-1 of the first 512 bytes of the file, and the last 20 bytes will be the SHA-1 of the next 512 bytes. :param str hash_algorithm: the name of the hash algorithm to use (normally ``"sha1"`` or ``"md5"``) :param offset: offset into the file to begin hashing (0 means to start from the beginning) :param length: number of bytes to hash (0 means continue to the end of the file) :param int block_size: number of bytes to hash per result (must not be less than 256; 0 means to compute only one hash of the entire segment) :return: `str` of bytes representing the hash of each block, concatenated together :raises: ``IOError`` -- if the server doesn't support the "check-file" extension, or possibly doesn't support the hash algorithm requested .. note:: Many (most?) servers don't support this extension yet. .. versionadded:: 1.4 z check-file)rr?rrrget_text get_remainder)r'hash_algorithmrSlength block_sizernrorms r*checkSFTPFile.checkfsc\##   KK  &M &M      " r,cXlg)ah Turn on/off the pipelining of write operations to this file. When pipelining is on, paramiko won't wait for the server response after each write operation. Instead, they're collected as they come in. At the first non-write operation (including `.close`), all remaining server responses are collected. This means that if there was an error with one of your later writes, an exception might be thrown from within `.close` instead of `.write`. By default, files are not pipelined. :param bool pipelined: ``True`` if pipelining should be turned on for this file; ``False`` otherwise .. versionadded:: 1.5 N)r)r'rs r* set_pipelinedSFTPFile.set_pipelineds $#r,NcUcUR5Rn/nURnXA:a5[URX- 5nUR XE45 XE- nXA:aM5[ U5S:aURX25 gg)ae Pre-fetch the remaining contents of this file in anticipation of future `.read` calls. If reading the entire file, pre-fetching can dramatically improve the download speed by avoiding roundtrip latency. The file's contents are incrementally buffered in a background thread. The prefetched data is stored in a buffer until read via the `.read` method. Once data has been read, it's removed from the buffer. The data may be read in a random order (using `.seek`); chunks of the buffer that haven't been read will continue to be buffered. :param int file_size: When this is ``None`` (the default), this method calls `stat` to determine the remote file size. In some situations, doing so can cause exceptions or hangs (see `#562 `_); as a workaround, one may call `stat` explicitly and pass its value in via this parameter. :param int max_concurrent_requests: The maximum number of concurrent read requests to prefetch. See `.SFTPClient.get` (its ``max_concurrent_prefetch_requests`` param) for details. .. versionadded:: 1.5.1 .. versionchanged:: 1.16.0 The ``file_size`` parameter was added (with no default value). .. versionchanged:: 1.16.1 The ``file_size`` parameter was made optional for backwards compatibility. .. versionchanged:: 3.3 Added ``max_concurrent_requests``. Nr)rrrarirjrtrP_start_prefetch)r' file_sizemax_concurrent_requestschunksnrxs r*rdSFTPFile.prefetchsB   ++I MMm--y}=E MM1* % JAm v;?   A r,c## URR[SR[ UR 5U55 /nUHrupEUR U5(dURXE5(aM3US:dM;[XPR5nURXF45 XF- nXV-nUS:aM7Mt URX25 UH-nURUS5 URUS5v M/ g7f)a Read a set of blocks from the file by (offset, length). This is more efficient than doing a series of `.seek` and `.read` calls, since the prefetch machinery is used to retrieve all the requested blocks at once. :param chunks: a list of ``(offset, length)`` tuples indicating which sections of the file to read :param int max_concurrent_prefetch_requests: The maximum number of concurrent read requests to prefetch. See `.SFTPClient.get` (its ``max_concurrent_prefetch_requests`` param) for details. :return: a list of blocks read, in the same order as in ``chunks`` .. versionadded:: 1.5.4 .. versionchanged:: 3.3 Added ``max_concurrent_prefetch_requests``. zreadv({}, {!r})rN)rr:rr;rrr^rRrirjrtrrread)r'r max_concurrent_prefetch_requests read_chunksrSrT chunk_sizerIs r*readvSFTPFile.readvs(  $++GDKK,@&I  "LF--00>>( '<'<= ""F#78$" (# [KA IIadO))AaD/ !sA?D5D&&s+%$%-,%$sC -C C  C+ cU[:XaURRU5 gU[ :wa [ S5eUR5nUR X0R;aVURUupgXPRU'URU [UR5S:XaSUl SSS5 gSSS5 M}![anX@lSnAgSnAff=f!,(df  N-=f)NrhTr) rr_convert_status Exceptionr%r r rlr$r!r rPr)r'rnrorermrSrs r*_async_responseSFTPFile._async_response7s ? * ))#.  =O, ,~~$$000%)%;%;C%@NF26''/..s34112a7.2+%$0%  *()%%  *%$s$C AC( C%C  C%( C6cHURbURnSUlUeg)z.if there's a saved exception, raise & clear itN)r%)r'rIs r*rcSFTPFile._check_exceptionMs+  ,%%A$(D !G -r,) rr rr!r$rrrar&r%rrr)rrM)F)r)rrr)T)NNr)#__name__ __module__ __qualname____firstlineno____doc__rjrr3r6r1rRr^rerpr{r~rrrrrrrrrrrrdrrrrrrc__static_attributes__rHr,r*rr1s !" 8 ("<  , ++ - - <<$<, <:x#(,B\+"^ ?&,r,r)rbinasciir collectionsrrBr"rparamiko.commonrr paramiko.filer paramiko.utilr paramiko.sftpr r r r r rrrrrrparamiko.sftp_attrrrrHr,r*rsK&   +&    .a|ar,