IiwJRSSKJr SSKJrJrJrJrJr SSKJ r J r "SS\ 5r g))BytesIO)linefeed_byte_valuecrlfcr_byte linefeed_byte cr_byte_value)ClosingContextManageruc\rSrSrSrSrSrSrSrSr Sr Sr Sr S r S rS rS rS rSrSrSrSrSrSrSrSrS'SjrS'SjrS'SjrS(SjrSrSrSr Sr!\"S5r#S r$S!r%S"r&S)S#jr'S$r(S%r)S&r*g)* BufferedFilezW Reusable base class to implement Python-style file buffering around a simpler stream. i r @cSUlSUlURUl[ 5Ul[ 5UlSUlSUl S=Ul Ul SUl g)NrF) newlines_flags_DEFAULT_BUFSIZE_bufsizer_wbufferbytes_rbuffer_at_trailing_cr_closed_pos_realpos_sizeselfs 3/venv/lib/python3.13/site-packages/paramiko/file.py__init__BufferedFile.__init__3sU  --    $ %&% DM c$UR5 gN)closer"s r$__del__BufferedFile.__del__Bs  r'c>UR(a [S5eU$)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__BufferedFile.__iter__Es <<;< < r'c2UR5 SUlg)z> Close the file. Future read and write operations will fail. TN)flushrr"s r$r*BufferedFile.closeQs  r'ctURURR55 [5Ulg)zc Write out any data in the write buffer. This may do nothing if write buffering is not turned on. N) _write_allrgetvaluerr"s r$r2BufferedFile.flushXs)  ..01  r'c@UR5nU(d[eU$)aP 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`, or `bytes` if the file was opened in binary mode) read from the file. )readline StopIteration)r#lines r$__next__BufferedFile.__next__as}}  r'cNURUR-UR:H$)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$readableBufferedFile.readablers  dnn,??r'cNURUR-UR:H$)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$writableBufferedFile.writable|s  doo-$//AAr'cg)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$seekableBufferedFile.seekablesr'cfUR[U55nX!S[U5&[U5$)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$readintoBufferedFile.readintos.yyT# [s4y4yr'NcnUR(a [S5eURUR-(d [S5eUbUS:a[ UR 5n[ 5UlU=R[U5- slURUR5nUb[U5S:XaOOURU5 U=R[U5- sl U=R[U5- slM~[ U5$U[UR 5::aCUR SUnUR USUlU=R[U5- slU$[UR 5U:aU[UR 5- nURUR-(a[UR U5nURU5nUb[U5S:XaONU=R U- slU=R[U5- sl [UR 5U:aMUR SUnUR USUlU=R[U5- slU$![a SnGNf=f![a SnNf=f)a1 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)rIOErrorrr? bytearrayrrrrL_readrEOFErrorextendr FLAG_BUFFEREDmaxr)r#sizeresultnew_data read_sizes r$rKBufferedFile.reads," <<*+ + dnn,89 9 LdQht}}-F!GDM IIV $I$#zz$*?*?@H$#h-1*< h' 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$JJ% J"!J"% J43J4c2UR(a [S5eURUR-(d [S5eURnSnUR (aqURUR -(aS[U5S:aDUS[:XaUSSnUR[5 OUR[5 SUlUb5US:a/[U5U:aX!SUlUSUnSnOU[U5- nO URn[U;d(URUR -(a [U;aOURU5nUb[U5S:XaX[!5UlU=R"[U5- slURUR$-(aU$['U5$X%- nU=R([U5- slGMUR+[5nURUR -(a(UR+[5nUS:a Xv:dUS:aUnUS:XaIU=R"[U5- slURUR$-(aU$['U5$US-nX&[,:Xa U[U5:aX([:XaUS- nU(aX(SUR-UlO X(SUlX&Un USU[-n[UR5S:XaU [:XaSUlOURU 5 U=R"[U5- slURUR$-(aU$['U5$![a SnGN5f=f) aE 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 rRzFile not open for readingFTrrN)rrSrr?rrFLAG_UNIVERSAL_NEWLINErLr_record_newlinerrrrrUrVrr FLAG_BINARYr r findr) r#rZr; truncatednr\posrposxposlfs r$r9BufferedFile.readlines. <<*+ + dnn,56 6}} $$KK$"="==IM7118D((.((1',$ tqyt9$$(KDM;D $I3t9$MM$ d999go ::a= c(mq&8 %  SY& #{{T-=-==tJ1T7J  D MMS] *MORii & ;;44 499W%D  cAg "9 IIT "I;;)9)994 Fqw FQw I &s4y  11 AID  K$--7DM KDM d^DSzM)  ! #"-$(D   $ SY {{T%5%55tB1T7BU  sN NNc/nSnUR5n[U5S:XaU$URU5 U[U5- nUbX1:aU$MN)av 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)r9rLappend)r#sizehintlines byte_countr;s r$ readlinesBufferedFile.readlines@se ==?D4yA~  LL  #d) #J$:+A r'c[S5e)aD 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.rS)r#offsetwhences r$seekBufferedFile.seekVs$677r'cUR$)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). )rr"s r$tellBufferedFile.telljsyyr'cH[U[5(aURS5nUR(a [ S5eUR UR -(d [ S5eUR UR-(dURU5 gURRU5 UR UR-(aUR[5nUS:azURR5nU[U5[U5- - nURUSUS-5 [!5Ul URRX2S-S5 gURR#5UR$:aUR'5 g)a 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-8rRzFile not open for writingNrr) isinstancestrencoderrSrrCrXr5rwriteFLAG_LINE_BUFFEREDrfindrr6rLrrzrr2)r#rNlast_newline_poswbufs r$rBufferedFile.writets> dC ;;w'D <<*+ + doo-56 6 d000 OOD !  D! ;;00 0#zz-8 1$}}--/ CID $99 %;'7!'; <= '   ##DA)=)?$@A  ==   4== 0 JJLr'c8UHnURU5 M g)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)r)r#sequencer;s r$ writelinesBufferedFile.writelinessD JJt r'cU$)zg Identical to ``iter(f)``. This is a deprecated file interface that predates Python iterator support. rGr"s r$ xreadlinesBufferedFile.xreadliness  r'cUR$r))rr"s r$closedBufferedFile.closeds ||r'c[5e)zh (subclass override) Read data from the stream. Return ``None`` or raise ``EOFError`` to indicate EOF. )rV)r#rZs r$rUBufferedFile._reads jr'c[S5e)z1 (subclass override) Write data into the stream. zwrite not implementedrt)r#rNs r$_writeBufferedFile._writes -..r'cg)a1 (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, rrGr"s r$ _get_sizeBufferedFile._get_sizesr'cURUlUS:aSnUS:Xa-U=RURUR--slOUS:aFX lU=RUR-slU=RUR)-slO3US:Xa-U=RURUR-)-slSU;dSU;aU=RUR -slSU;dSU;aU=RUR -slSU;aYU=RUR UR--slUR5Ul UR=Ul Ul SU;aU=RUR-slSU;a'U=RUR-slS Ulg g ) z= Subclasses call this method to initialize the BufferedFile. rrr+wabUN)rrrrXrr?rC FLAG_APPENDrr!rr rcrar)r#modebufsizes r$ _set_modeBufferedFile._set_modesm -- Q;G a< KK4--0G0GG GK q[#M KK4-- -K KKD333 3K \ KKT//$2I2IIJ JK 4KSD[ KK4>> )K 4KSD[ KK4?? *K $; KK4??T-=-== =K)DJ(, 2DI $; KK4++ +K $; KK466 6K!DM r'cp[U5n[U5S:aURU5nX#SnURUR-(a.U=R U- slUR =UlUlO*U=R U- slU=RU- sl[U5S:aMg)Nr) memoryviewrLrrrr!rr )r#raw_datarNcounts r$r5BufferedFile._write_alls(#$i!mKK%Ers($3q((q(r'