U
vfwJ @ sL d dl mZ d dlmZmZmZmZmZ d dlm Z m
Z
G dd de Z dS ) )BytesIO)linefeed_byte_valuecrlfcr_byte
linefeed_byte
cr_byte_value)ClosingContextManageruc @ s e Zd ZdZdZdZdZdZdZdZ dZ
dZ dZ d Z
d
Zd d Zd
d Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zd d Zd@d d!ZdAd"d#ZdBd$d%ZdCd&d'Z d(d) Z d*d+ Z d,d- Z d.d/ Z e!d0d1 Z"d2d3 Z#d4d5 Z$d6d7 Z%dDd:d;Z&dd? Z(d S )E BufferedFilezc
Reusable base class to implement Python-style file buffering around a
simpler stream.
i r @ c C sF d | _ d| _| j| _t | _t | _d| _d| _ d | _
| _ d| _ d S )Nr F)
newlines_flags_DEFAULT_BUFSIZE_bufsizer _wbufferbytes_rbuffer_at_trailing_cr_closed_pos_realpos_sizeself r >/opt/alt/python38/lib/python3.8/site-packages/paramiko/file.py__init__3 s zBufferedFile.__init__c C s | d S N)closer r r r! __del__B s zBufferedFile.__del__c C s | j rtd| 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.
z I/O operation on closed file)r
ValueErrorr r r r! __iter__E s zBufferedFile.__iter__c C s | d| _dS )zN
Close the file. Future read and write operations will fail.
TN)flushr r r r r! r$ Q s zBufferedFile.closec C s | | j t | _dS )z{
Write out any data in the write buffer. This may do nothing if write
buffering is not turned on.
N)
_write_allr getvaluer r r r r! r( X s zBufferedFile.flushc C s | }|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`, or `bytes` if the file was opened in binary mode)
read from the file.
)readline
StopIteration)r liner r r! __next__a s zBufferedFile.__next__c C s | j | j@ | jkS )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 r r r! readabler s zBufferedFile.readablec C s | j | j@ | jkS )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 r r r! writable| s zBufferedFile.writablec C s dS )z
Check if the file supports random access.
:returns:
`True` if the file supports random access. If `False`, `seek` will
raise an exception.
Fr r r r r! seekable s zBufferedFile.seekablec C s& | t|}||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 Zbuffdatar r r! readinto s zBufferedFile.readintoNc C s | j rtd| j| j@ s"td|dks2|dk rt| j}t | _| jt|7 _z| | j
}W n t k
r~ d}Y nX |dkst|dkrq| | | j
t|7 _
| jt|7 _qVt|S |t| jkr| jd| }| j|d | _| jt|7 _|S t| j|k r|t| j }| j| j@ rJt| j|}z| |}W n t k
rr d}Y nX |dkst|dkrq| j|7 _| j
t|7 _
q| jd| }| j|d | _| jt|7 _|S )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 closedz File is not open for readingNr )r IOErrorr r/ bytearrayr r r r5 _readr EOFErrorextendr
FLAG_BUFFEREDmaxr )r sizeresultnew_data read_sizer r r! r4 sN
zBufferedFile.readc
C s | j rtd| j| j@ s"td| j}d}| jr~| j| j@ r~t|dkr~|d tkrn|dd }| t
n
| t d| _|dk r|dkrt||kr||d | _|d| }d}q|t| }n| j }t
|ks| j| j@ rt |krqz| |}W n tk
r d}Y nX |dks2t|dkrft | _| jt|7 _| j| j@ r^|S t|S ||7 }| jt|7 _q,|t
}| j| j@ r|t }|dkr||k s|dk r|}|dkr| jt|7 _| j| j@ r|S t|S |d }|| tkr6|t|k r6|| tkr6|d7 }|rR||d | j | _n||d | _||| } |d| t
}t| jdkr| t krd| _n
| | | jt|7 _| j| j@ r|S t|S ) 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
r8 zFile not open for readingFr r NT)r r9 r r/ r r FLAG_UNIVERSAL_NEWLINEr5 r _record_newliner r r r r; r< r r FLAG_BINARYr r findr )
r r@ r- truncatednrB posrposZxposlfr r r! r+ s
zBufferedFile.readlinec C sL g }d}| }t|dkr qH|| |t|7 }|dk r||krqHq|S )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 N)r+ r5 append)r sizehintlinesZ
byte_countr- r r r! readlines@ s
zBufferedFile.readlinesc C s t ddS )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.
z File does not support seeking.Nr9 )r offsetwhencer r r! seekV s zBufferedFile.seekc C s | j S )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 r r r! tellj s zBufferedFile.tellc C s t |tr|d}| jr"td| j| j@ s6td| j| j@ sP| | dS | j
| | j| j @ r| t
}|dkr| j }|t|t| 7 }| |d|d t | _ | j
||d d dS | j | jkr| dS )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-8r8 zFile not open for writingNr r )
isinstancestrencoder r9 r r1 r> r) r writeFLAG_LINE_BUFFEREDrfindr r* r5 r rV r r( )r r6 Zlast_newline_posZwbufr r r! rZ t s,
zBufferedFile.writec C s |D ]}| | qdS )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)rZ )r sequencer- r r r!
writelines s zBufferedFile.writelinesc C s | S )z
Identical to ``iter(f)``. This is a deprecated file interface that
predates Python iterator support.
r r r r r!
xreadlines s zBufferedFile.xreadlinesc C s | j S r# )r r r r r! closed s zBufferedFile.closedc C s
t dS )z
(subclass override)
Read data from the stream. Return ``None`` or raise ``EOFError`` to
indicate EOF.
N)r< )r r@ r r r! r; s zBufferedFile._readc C s t ddS )zI
(subclass override)
Write data into the stream.
zwrite not implementedNrR )r r6 r r r! _write s zBufferedFile._writec C s dS )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,
r r r r r r! _get_size s zBufferedFile._get_sizerrD c C s: | j | _|dk rd}|dkr4| j| j| jB O _nR|dkrf|| _| j| jO _| j| j M _n |dkr| j| j| jB M _d|ksd|kr| j| jO _d|ksd|kr| j| jO _d|kr| j| j| jB O _| | _ | j | _
| _ d|kr| j| j O _d|kr6| j| j
O _d | _d S )
zM
Subclasses call this method to initialize the BufferedFile.
r r rc +wabUN)r r r r> r[ r/ r1 FLAG_APPENDrb r r r rG rE r )r modebufsizer r r! _set_mode s0
zBufferedFile._set_modec C sv t |}t|dkrr| |}||d }| j| j@ rT| j|7 _| j | _| _q| j|7 _| j|7 _qd S )Nr )
memoryviewr5 ra r ri r r r )r raw_datar6 countr r r! r) s
zBufferedFile._write_allc C sd | j | j@ sd S | jd kr"|| _n>| j|krFt| jtrF| j|f| _n|| jkr`| j|f7 _d S r# )r rE r rW r )r newliner r r! rF s
z BufferedFile._record_newline)N)N)N)r )rc rD ))__name__
__module__ __qualname____doc__r SEEK_SETSEEK_CURSEEK_ENDr/ r1 ri rG r> r[ rE r" r% r' r$ r( r. r0 r2 r3 r7 r4 r+ rQ rU rV rZ r^ r_ propertyr` r; ra rb rl r) rF r r r r! r
sL
;
i
$
(r
N) ior Zparamiko.commonr r r r r Z
paramiko.utilr r r
r r r r! s