aL^ddlmZmZmZmZmZddlmZmZm Z m Z m Z ddl m Z Gdde Zy))linefeed_byte_valuecrlfcr_byte linefeed_byte cr_byte_value)BytesIOPY2u bytes_types text_type)ClosingContextManagerceZdZdZdZdZdZdZdZdZ dZ dZ dZ d Z d Zd Zd Zd ZdZdZerdZndZdZdZdZdZd&dZd&dZd&dZd'dZdZdZ dZ!dZ"e#dZ$d Z%d!Z&d"Z'd(d#Z(d$Z)d%Z*y)) BufferedFilezc Reusable base class to implement Python-style file buffering around a simpler stream. i r @cd|_d|_|j|_t |_t |_d|_d|_ dx|_ |_ d|_ y)NrF) newlines_flags_DEFAULT_BUFSIZE_bufsizer_wbufferbytes_rbuffer_at_trailing_cr_closed_pos_realpos_sizeselfs -lib/python3.12/site-packages/paramiko/file.py__init__zBufferedFile.__init__2sU  --    $ %&% DM c$|jyN)closer$s r&__del__zBufferedFile.__del__As  r(c4|jr td|S)z Returns an iterator that can be used to iterate over the lines in this file. This iterator happens to return the file itself, since a file is its own iterator. :raises: ``ValueError`` -- if the file is closed. zI/O operation on closed file)r ValueErrorr$s r&__iter__zBufferedFile.__iter__Ds <<;< < r(c2|jd|_y)zN Close the file. Future read and write operations will fail. TN)flushr r$s r&r+zBufferedFile.closePs  r(ct|j|jjt|_y)z{ Write out any data in the write buffer. This may do nothing if write buffering is not turned on. N) _write_allrgetvaluerr$s r&r1zBufferedFile.flushWs)  ..01  r(c6|j}|st|S)a\ Returns the next line from the input, or raises ``StopIteration`` when EOF is hit. Unlike Python file objects, it's okay to mix calls to `next` and `readline`. :raises: ``StopIteration`` -- when the end of the file is reached. :returns: a line (`str`) read from the file. readline StopIterationr%lines r&nextzBufferedFile.nextb==?D##Kr(c6|j}|st|S)a^ Returns the next line from the input, or raises ``StopIteration`` when EOF is hit. Unlike python file objects, it's okay to mix calls to `.next` and `.readline`. :raises: ``StopIteration`` -- when the end of the file is reached. :returns: a line (`str`) read from the file. r6r9s r&__next__zBufferedFile.__next__sr<r(cN|j|jz|jk(S)z Check if the file can be read from. :returns: `True` if the file can be read from. If `False`, `read` will raise an exception. )r FLAG_READr$s r&readablezBufferedFile.readables  dnn,??r(cN|j|jz|jk(S)z Check if the file can be written to. :returns: `True` if the file can be written to. If `False`, `write` will raise an exception. )r FLAG_WRITEr$s r&writablezBufferedFile.writables  doo-$//AAr(cy)z Check if the file supports random access. :returns: `True` if the file supports random access. If `False`, `seek` will raise an exception. Fr$s r&seekablezBufferedFile.seekablesr(ch|jt|}||dt|t|S)z Read up to ``len(buff)`` bytes into ``bytearray`` *buff* and return the number of bytes read. :returns: The number of bytes read. N)readlen)r%buffdatas r&readintozBufferedFile.readintos0yyT# [s4y4yr(Nc|jr td|j|jzs td||dkr|j}t |_|xj t|z c_ |j|j}|t|dk(r |S||z }|xjt|z c_ |xj t|z c_q|t|jkrC|jd|}|j|d|_|xj t|z c_|St|j|kr|t|jz }|j|jzrt|j|} |j|}|t|dk(rnL|xj|z c_|xjt|z c_ t|j|kr|jd|}|j|d|_|xj t|z c_|S#t$rd}YwxYw#t$rd}YwxYw)a Read at most ``size`` bytes from the file (less if we hit the end of the file first). If the ``size`` argument is negative or omitted, read all the remaining data in the file. .. note:: ``'b'`` mode flag is ignored (``self.FLAG_BINARY`` in ``self._flags``), because SSH treats all files as binary, since we have no idea what encoding the file is in, or even if the file is text data. :param int size: maximum number of bytes to read :returns: data read from the file (as bytes), or an empty string if EOF was encountered immediately File is closedzFile is not open for readingNr)r IOErrorrr@rrr!rJ_readrEOFErrorr" FLAG_BUFFEREDmaxr)r%sizeresultnew_data read_sizes r&rIzBufferedFile.reads$" <<*+ + dnn,89 9 LdQh]]F!GDM IIV $I$#zz$*?*?@H$#h-1*<M(" X.  S]*  3t}}% %]]5D)F MM$%0DM IIV $IM$-- 4's4==11I{{T/// y9  ::i0 c(mq&8 MMX %M MMS] *M$-- 4'u% de,  S[  9 $#H$&  s$>I)I, I)(I), I:9I:c|jr td|j|jzs td|j}d} |j rj|j|j zrQt|dkDrC|dtk(r|dd}|jtn|jtd|_|4|dk\r/t||k\r||d|_|d|}d}n|t|z }n |j}t|vs!|j|j zr t|vrn |j|}|t|dk(rSt!|_|xj"t|z c_|j|j$zr|St'|S||z }|xj(t|z c_||j+t}|j|j zr&|j+t}|dk\r ||ks|dkr|}|dk(rD|xj"t|z c_|j|j$zr|St'|S|dz}||t,k(r|t|kr||tk(r|dz }|r||d|jz|_n ||d|_|||} |d|tz}t|jdk(r| tk(rd|_n|j| |xj"t|z c_|j|j$zr|St'|S#t$rd}YwxYw) a Read one entire line from the file. A trailing newline character is kept in the string (but may be absent when a file ends with an incomplete line). If the size argument is present and non-negative, it is a maximum byte count (including the trailing newline) and an incomplete line may be returned. An empty string is returned only when EOF is encountered immediately. .. note:: Unlike stdio's ``fgets``, the returned string contains null characters (``'\0'``) if they occurred in the input. :param int size: maximum length of returned string. :returns: next line of the file, or an empty string if the end of the file has been reached. If the file was opened in binary (``'b'``) mode: bytes are returned Else: the encoding of the file is assumed to be UTF-8 and character strings (`str`) are returned rOzFile not open for readingFTrrN)r rPrr@rrFLAG_UNIVERSAL_NEWLINErJr_record_newlinerrrrrQrRrr! FLAG_BINARYr r"findr) r%rUr: truncatednrWposrposxposlfs r&r7zBufferedFile.readlines. <<*+ + dnn,56 6}} $$KK$"="==IM7118D((.((1',$ tqyt9$$(KDM;D $I3t9$MM$ d999go ::a= c(mq&8 %  SY& #{{T-=-==tJ1T7J H D MMS] *MORii & ;;44 499W%D s cAg "9 IIT "I;;)9)994 Fqw FQw I &s4y T 11 AID  K$--7DM KDM #d^DSzM)  ! #"-$(D   $ SY {{T%5%55tB1T7BU  s.M MMcg}d} |j}t|dk(r |S|j||t|z }|||k\r |SK)a Read all remaining lines using `readline` and return them as a list. If the optional ``sizehint`` argument is present, instead of reading up to EOF, whole lines totalling approximately sizehint bytes (possibly after rounding up to an internal buffer size) are read. :param int sizehint: desired maximum number of bytes to read. :returns: list of lines read from the file. r)r7rJappend)r%sizehintlines byte_countr:s r& readlineszBufferedFile.readlinesPsg ==?D4yA~  LL  #d) #J$:+A r(ctd)a Set the file's current position, like stdio's ``fseek``. Not all file objects support seeking. .. note:: If a file is opened in append mode (``'a'`` or ``'a+'``), any seek operations will be undone at the next write (as the file position will move back to the end of the file). :param int offset: position to move to within the file, relative to ``whence``. :param int whence: type of movement: 0 = absolute; 1 = relative to the current position; 2 = relative to the end of the file. :raises: ``IOError`` -- if the file doesn't support random access. zFile does not support seeking.rP)r%offsetwhences r&seekzBufferedFile.seekfs$677r(c|jS)z Return the file's current position. This may not be accurate or useful if the underlying file doesn't support random access, or was opened in append mode. :returns: file position (`number ` of bytes). )r!r$s r&tellzBufferedFile.tellzsyyr(ct|tr|jd}|jr t d|j |j zs t d|j |jzs|j|y|jj||j |jzr|jt}|dk\r{|jj}|t|t|z z }|j|d|dzt!|_ |jj||dzdy|jj#|j$k\r|j'y)a8 Write data to the file. If write buffering is on (``bufsize`` was specified and non-zero), some or all of the data may not actually be written yet. (Use `flush` or `close` to force buffered data to be written out.) :param data: ``str``/``bytes`` data to write zutf-8rOzFile not open for writingNrr) isinstancer encoder rPrrCrSr3rwriteFLAG_LINE_BUFFEREDrfindrr4rJrrqrr1)r%rLlast_newline_poswbufs r&ruzBufferedFile.writes> dI &;;w'D <<*+ + doo-56 6 d000 OOD !  D! ;;00 0#zz-8 1$}}--/ CID $99 %;'7!'; <= '   ##D)9A)=)?$@A  ==   4== 0 JJLr(c4|D]}|j|y)a? Write a sequence of strings to the file. The sequence can be any iterable object producing strings, typically a list of strings. (The name is intended to match `readlines`; `writelines` does not add line separators.) :param sequence: an iterable sequence of strings. N)ru)r%sequencer:s r& writelineszBufferedFile.writeliness" D JJt  r(c|S)z Identical to ``iter(f)``. This is a deprecated file interface that predates Python iterator support. rFr$s r& xreadlineszBufferedFile.xreadliness  r(c|jSr*)r r$s r&closedzBufferedFile.closeds ||r(ct)z (subclass override) Read data from the stream. Return ``None`` or raise ``EOFError`` to indicate EOF. )rR)r%rUs r&rQzBufferedFile._reads jr(ctd)zI (subclass override) Write data into the stream. zwrite not implementedrl)r%rLs r&_writezBufferedFile._writes -..r(cy)ai (subclass override) Return the size of the file. This is called from within `_set_mode` if the file is opened in append mode, so the file position can be tracked and `seek` and `tell` will work correctly. If the file is a stream that can't be randomly accessed, you don't need to override this method, rrFr$s r& _get_sizezBufferedFile._get_sizesr(c|j|_|dkrd}|dk(r-|xj|j|jzzc_n~|dkDrG||_|xj|jzc_|xj|jzc_n2|dk(r-|xj|j|jzzc_d|vsd|vr|xj|j zc_d|vsd|vr|xj|j zc_d|vrY|xj|j |jzzc_|j|_ |jx|_ |_ d|vr|xj|jzc_d|vr'|xj|jzc_d |_y y ) zM Subclasses call this method to initialize the BufferedFile. rrr+wabUN)rrrrSrvr@rC FLAG_APPENDrr#r!r"r]r[r)r%modebufsizes r& _set_modezBufferedFile._set_modeso -- Q;G a< KK4--0G0GG GK q[#DM KK4-- -K KKD333 3K \ KKT//$2I2IIJ JK 4KSD[ KK4>> )K 4KSD[ KK4?? *K $; KK4??T-=-== =K)DJ(, 2DI $; KK4++ +K $; KK466 6K!DM r(cLt|dkDr|j|}||d}|j|jzr.|xj|z c_|jx|_|_n*|xj |z c_|xj |z c_t|dkDry)Nr)rJrrrr#r!r")r%rLcounts r&r3zBufferedFile._write_alls$i!mKK%ErArDrGrMrIr7rjrorqrur|r~propertyrrQrrrr3r\rFr(r&rrs HHHIJKKM!    " @B 9vgCR,8("H  / &!P  (r(rN)paramiko.commonrrrrrparamiko.py3compatrr r r r paramiko.utilr rrFr(r&rs*$GF/C((C(r(