f c @ s d Z d d l Z d d l Z d d l Z d d l Z y d d l m Z Wn" e k
rn d d l m Z Yn Xd d l
Z
d d l
m Z m Z m
Z
m Z d d d h Z e e d r e j e j e j e j n d d Z e Z d
d e e e e e d d Z Gd
d d Z Gd d d Z y
e
j Z Wn+ e k
rpGd d d e e Z Yn XGd d d d e j Z e
j j! e Gd d d e Z" e
j" j! e" d d l# m$ Z$ e" j! e$ Gd d d e Z% e
j% j! e% Gd d d e% Z& Gd d d e% Z' Gd d d e& Z( Gd! d" d" e& Z) Gd# d$ d$ e% Z* Gd% d& d& e) e( Z+ Gd' d( d( e Z, e
j, j! e, Gd) d* d* e j- Z. Gd+ d, d, e, Z/ Gd- d. d. e/ Z0 d S(/ u)
Python implementation of the io module.
i N( u
allocate_lock( u __all__u SEEK_SETu SEEK_CURu SEEK_ENDi i u SEEK_HOLEi i u rc ( C s> t | t t t f s+ t d | n t | t sM t d | n t | t so t d | n | d k r t | t r t d | n | d k r t | t r t d | n t | } | t d st | t | k rt d | n d | k } d | k }
d | k } d
| k } d | k }
d | k } d
| k } d | k r| s| s| rt d n d }
n | r| rt d n | |
| | d k rt d n | p|
p| p| st d n | r(| d k r(t d n | rI| d k rIt d n | rj| d k rjt d n t
| | r|d pd |
rd pd | rd pd | rd
pd |
rd pd | d | } d } | d k s| d k r| j rd } d } n | d k rkt
} y t j | j j } Wn t j t f k
rRYqkX| d k rk| } qkn | d k rt d n | d k r| r| St d n |
rt | | } nL | s| s| rt | | } n( |
rt | | } n t d | | r| St | | | | | } | | _ | S(! u Open file and return a stream. Raise IOError upon failure.
file is either a text or byte string giving the name (and the path
if the file isn't in the current working directory) of the file to
be opened or an integer file descriptor of the file to be
wrapped. (If a file descriptor is given, it is closed when the
returned I/O object is closed, unless closefd is set to False.)
mode is an optional string that specifies the mode in which the file is
opened. It defaults to 'r' which means open for reading in text mode. Other
common values are 'w' for writing (truncating the file if it already
exists), 'x' for exclusive creation of a new file, and 'a' for appending
(which on some Unix systems, means that all writes append to the end of the
file regardless of the current seek position). In text mode, if encoding is
not specified the encoding used is platform dependent. (For reading and
writing raw bytes use binary mode and leave encoding unspecified.) The
available modes are:
========= ===============================================================
Character Meaning
--------- ---------------------------------------------------------------
'r' open for reading (default)
'w' open for writing, truncating the file first
'x' create a new file and open it for writing
'a' open for writing, appending to the end of the file if it exists
'b' binary mode
't' text mode (default)
'+' open a disk file for updating (reading and writing)
'U' universal newline mode (for backwards compatibility; unneeded
for new code)
========= ===============================================================
The default mode is 'rt' (open for reading text). For binary random
access, the mode 'w+b' opens and truncates the file to 0 bytes, while
'r+b' opens the file without truncation. The 'x' mode implies 'w' and
raises an `FileExistsError` if the file already exists.
Python distinguishes between files opened in binary and text modes,
even when the underlying operating system doesn't. Files opened in
binary mode (appending 'b' to the mode argument) return contents as
bytes objects without any decoding. In text mode (the default, or when
't' is appended to the mode argument), the contents of the file are
returned as strings, the bytes having been first decoded using a
platform-dependent encoding or using the specified encoding if given.
buffering is an optional integer used to set the buffering policy.
Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
line buffering (only usable in text mode), and an integer > 1 to indicate
the size of a fixed-size chunk buffer. When no buffering argument is
given, the default buffering policy works as follows:
* Binary files are buffered in fixed-size chunks; the size of the buffer
is chosen using a heuristic trying to determine the underlying device's
"block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
On many systems, the buffer will typically be 4096 or 8192 bytes long.
* "Interactive" text files (files for which isatty() returns True)
use line buffering. Other text files use the policy described above
for binary files.
encoding is the str name of the encoding used to decode or encode the
file. This should only be used in text mode. The default encoding is
platform dependent, but any encoding supported by Python can be
passed. See the codecs module for the list of supported encodings.
errors is an optional string that specifies how encoding errors are to
be handled---this argument should not be used in binary mode. Pass
'strict' to raise a ValueError exception if there is an encoding error
(the default of None has the same effect), or pass 'ignore' to ignore
errors. (Note that ignoring encoding errors can lead to data loss.)
See the documentation for codecs.register for a list of the permitted
encoding error strings.
newline is a string controlling how universal newlines works (it only
applies to text mode). It can be None, '', '\n', '\r', and '\r\n'. It works
as follows:
* On input, if newline is None, universal newlines mode is
enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
these are translated into '\n' before being returned to the
caller. If it is '', universal newline mode is enabled, but line
endings are returned to the caller untranslated. If it has any of
the other legal values, input lines are only terminated by the given
string, and the line ending is returned to the caller untranslated.
* On output, if newline is None, any '\n' characters written are
translated to the system default line separator, os.linesep. If
newline is '', no translation takes place. If newline is any of the
other legal values, any '\n' characters written are translated to
the given string.
closedfd is a bool. If closefd is False, the underlying file descriptor will
be kept open when the file is closed. This does not work when a file name is
given and must be True in that case.
A custom opener can be used by passing a callable as *opener*. The
underlying file descriptor for the file object is then obtained by calling
*opener* with (*file*, *flags*). *opener* must return an open file
descriptor (passing os.open as *opener* results in functionality similar to
passing None).
open() returns a file object whose type depends on the mode, and
through which the standard file operations such as reading and writing
are performed. When open() is used to open a file in a text mode ('w',
'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open
a file in a binary mode, the returned class varies: in read binary
mode, it returns a BufferedReader; in write binary and append binary
modes, it returns a BufferedWriter, and in read/write mode, it returns
a BufferedRandom.
It is also possible to use a string or bytearray as a file for both
reading and writing. For strings StringIO can be used like a file
opened in a text mode, and for bytes a BytesIO can be used like a file
opened in a binary mode.
u invalid file: %ru invalid mode: %ru invalid buffering: %ru invalid encoding: %ru invalid errors: %ru axrwb+tUu xu ru wu au +u tu bu Uu$ can't use U and writing mode at onceu' can't have text and binary mode at oncei u) can't have read/write/append mode at onceu/ must have exactly one of read/write/append modeu- binary mode doesn't take an encoding argumentu+ binary mode doesn't take an errors argumentu+ binary mode doesn't take a newline argumentu u openeri u invalid buffering sizeu can't have unbuffered text I/Ou unknown mode: %rNTFi( u
isinstanceu stru bytesu intu TypeErroru Noneu setu lenu
ValueErroru Trueu FileIOu Falseu isattyu DEFAULT_BUFFER_SIZEu osu fstatu filenou
st_blksizeu erroru AttributeErroru BufferedRandomu BufferedWriteru BufferedReaderu
TextIOWrapperu mode( u fileu modeu bufferingu encodingu errorsu newlineu closefdu openeru modesu creatingu readingu writingu appendingu updatingu textu binaryu rawu line_bufferingu bsu buffer( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu open" s v ( ?$ u openc B s& | Ee Z d Z d Z d d Z d S( u
DocDescriptoru% Helper for builtins.open.__doc__
c C s d t j S( Nu\ open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True)
( u openu __doc__( u selfu obju typ( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __get__ s u DocDescriptor.__get__N( u __name__u
__module__u __qualname__u __doc__u __get__( u
__locals__( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu
DocDescriptor s u
DocDescriptorc B s/ | Ee Z d Z d Z e Z d d Z d S( u OpenWrapperu Wrapper for builtins.open
Trick so that open won't become a bound method when stored
as a class variable (as dbm.dumb does).
See initstdio() in Python/pythonrun.c.
c O s
t | | S( N( u open( u clsu argsu kwargs( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __new__ s u OpenWrapper.__new__N( u __name__u
__module__u __qualname__u __doc__u
DocDescriptoru __new__( u
__locals__( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu OpenWrapper s u OpenWrapperc B s | Ee Z d Z d S( u UnsupportedOperationN( u __name__u
__module__u __qualname__( u
__locals__( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu UnsupportedOperation s u UnsupportedOperationc B s^ | Ee Z d Z d Z d d Z d d d Z d d Z d4 d d
Z d d Z d5 Z d
d Z d d Z
d d Z d4 d d Z d d Z d4 d d Z d d Z d4 d d Z e d d Z d4 d d Z d! d" Z d# d$ Z d% d& Z d' d( Z d6 d* d+ Z d, d- Z d. d/ Z d4 d0 d1 Z d2 d3 Z d4 S(7 u IOBaseu- The abstract base class for all I/O classes, acting on streams of
bytes. There is no public constructor.
This class provides dummy implementations for many methods that
derived classes can override selectively; the default implementations
represent a file that cannot be read, written or seeked.
Even though IOBase does not declare read, readinto, or write because
their signatures will vary, implementations and clients should
consider those methods part of the interface. Also, implementations
may raise UnsupportedOperation when operations they do not support are
called.
The basic type used for binary data read from or written to a file is
bytes. bytearrays are accepted too, and in some cases (such as
readinto) needed. Text I/O classes work with str data.
Note that calling any method (even inquiries) on a closed stream is
undefined. Implementations may raise IOError in this case.
IOBase (and its subclasses) support the iterator protocol, meaning
that an IOBase object can be iterated over yielding the lines in a
stream.
IOBase also supports the :keyword:`with` statement. In this example,
fp is closed after the suite of the with statement is complete:
with open('spam.txt', 'r') as fp:
fp.write('Spam and eggs!')
c C s t d | j j | f d S( u@ Internal: raise an IOError exception for unsupported operations.u %s.%s() not supportedN( u UnsupportedOperationu __class__u __name__( u selfu name( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu _unsupported( s u IOBase._unsupportedi c C s | j d d S( u$ Change stream position.
Change the stream position to byte offset pos. Argument pos is
interpreted relative to the position indicated by whence. Values
for whence are ints:
* 0 -- start of stream (the default); offset should be zero or positive
* 1 -- current stream position; offset may be negative
* 2 -- end of stream; offset is usually negative
Some operating systems / file systems could provide additional values.
Return an int indicating the new absolute position.
u seekN( u _unsupported( u selfu posu whence( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu seek/ s u IOBase.seekc C s | j d d S( u5 Return an int indicating the current stream position.i i ( u seek( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu tell? s u IOBase.tellc C s | j d d S( u Truncate file to size bytes.
Size defaults to the current IO position as reported by tell(). Return
the new size.
u truncateN( u _unsupported( u selfu pos( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu truncateC s u IOBase.truncatec C s | j d S( uu Flush write buffers, if applicable.
This is not implemented for read-only and non-blocking streams.
N( u _checkClosed( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu flushM s u IOBase.flushc C s+ | j s' z | j Wd d | _ Xn d S( ui Flush and close the IO object.
This method has no effect if the file is already closed.
NT( u _IOBase__closedu flushu True( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu closeW s u IOBase.closec C s y | j Wn Yn Xd S( u Destructor. Calls close().N( u close( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __del__b s u IOBase.__del__c C s d S( u Return a bool indicating whether object supports random access.
If False, seek(), tell() and truncate() will raise UnsupportedOperation.
This method may need to do a test seek().
F( u False( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu seekablep s u IOBase.seekablec C s1 | j s- t | d k r! d n | n d S( uE Internal: raise UnsupportedOperation if file is not seekable
u File or stream is not seekable.N( u seekableu UnsupportedOperationu None( u selfu msg( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu _checkSeekablex s u IOBase._checkSeekablec C s d S( u Return a bool indicating whether object was opened for reading.
If False, read() will raise UnsupportedOperation.
F( u False( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu readable s u IOBase.readablec C s1 | j s- t | d k r! d n | n d S( uE Internal: raise UnsupportedOperation if file is not readable
u File or stream is not readable.N( u readableu UnsupportedOperationu None( u selfu msg( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu _checkReadable s u IOBase._checkReadablec C s d S( u Return a bool indicating whether object was opened for writing.
If False, write() and truncate() will raise UnsupportedOperation.
F( u False( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu writable s u IOBase.writablec C s1 | j s- t | d k r! d n | n d S( uE Internal: raise UnsupportedOperation if file is not writable
u File or stream is not writable.N( u writableu UnsupportedOperationu None( u selfu msg( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu _checkWritable s u IOBase._checkWritablec C s | j S( u closed: bool. True iff the file has been closed.
For backwards compatibility, this is a property, not a predicate.
( u _IOBase__closed( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu closed s u
IOBase.closedc C s. | j r* t | d k r d n | n d S( u8 Internal: raise an ValueError if file is closed
u I/O operation on closed file.N( u closedu
ValueErroru None( u selfu msg( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu _checkClosed s u IOBase._checkClosedc C s | j | S( uC Context management protocol. Returns self (an instance of IOBase).( u _checkClosed( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __enter__ s
u IOBase.__enter__c G s | j d S( u+ Context management protocol. Calls close()N( u close( u selfu args( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __exit__ s u IOBase.__exit__c C s | j d d S( u Returns underlying file descriptor (an int) if one exists.
An IOError is raised if the IO object does not use a file descriptor.
u filenoN( u _unsupported( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu fileno s u
IOBase.filenoc C s | j d S( u{ Return a bool indicating whether this is an 'interactive' stream.
Return False if it can't be determined.
F( u _checkClosedu False( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu isatty s
u
IOBase.isattyi c s t d r' f d d } n d d } d k rH d
n t t sf t d n t } x[ d k s t | k r j | } | s Pn | | 7} | j d rr Pqr qr Wt | S( uQ Read and return a line of bytes from the stream.
If limit is specified, at most limit bytes will be read.
Limit should be an int.
The line terminator is always b'\n' for binary files; for text
files, the newlines argument to open can be used to select the line
terminator(s) recognized.
u peekc sZ j d } | s d S| j d d p5 t | } d k rV t | } n | S( Ni s
i ( u peeku findu lenu min( u readaheadu n( u limitu self( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu
nreadahead s u# IOBase.readline..nreadaheadc S s d S( Ni ( ( ( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu
nreadahead s i u limit must be an integeri s
Ni(
u hasattru Noneu
isinstanceu intu TypeErroru bytearrayu lenu readu endswithu bytes( u selfu limitu
nreadaheadu resu b( ( u limitu selfu* /opt/alt/python33/lib64/python3.3/_pyio.pyu readline s !
u IOBase.readlinec C s | j | S( N( u _checkClosed( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __iter__ s
u IOBase.__iter__c C s | j } | s t n | S( N( u readlineu
StopIteration( u selfu line( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __next__ s u IOBase.__next__c C sp | d k s | d k r" t | Sd } g } x; | D]3 } | j | | t | 7} | | k r5 Pq5 q5 W| S( u Return a list of lines from the stream.
hint can be specified to control the number of lines read: no more
lines will be read if the total size (in bytes/characters) of all
lines so far exceeds hint.
i N( u Noneu listu appendu len( u selfu hintu nu linesu line( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu readlines s
u IOBase.readlinesc C s, | j x | D] } | j | q Wd S( N( u _checkClosedu write( u selfu linesu line( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu
writelines s
u IOBase.writelinesNFi( u __name__u
__module__u __qualname__u __doc__u _unsupportedu seeku tellu Noneu truncateu flushu Falseu _IOBase__closedu closeu __del__u seekableu _checkSeekableu readableu _checkReadableu writableu _checkWritableu propertyu closedu _checkClosedu __enter__u __exit__u filenou isattyu readlineu __iter__u __next__u readlinesu
writelines( u
__locals__( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu IOBase s4
% u IOBaseu metaclassc B sM | Ee Z d Z d Z d d d Z d d Z d d Z d d
Z d S(
u RawIOBaseu Base class for raw binary I/O.i c C ss | d k r d } n | d k r+ | j St | j } | j | } | d k r\ d S| | d =t | S( u Read and return up to n bytes, where n is an int.
Returns an empty bytes object on EOF, or None if the object is
set not to block and has no data to read.
i i Ni( u Noneu readallu bytearrayu __index__u readintou bytes( u selfu nu b( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu read! s
u RawIOBase.readc C sJ t } x& | j t } | s% Pn | | 7} q | rB t | S| Sd S( u+ Read until EOF, using multiple read() call.N( u bytearrayu readu DEFAULT_BUFFER_SIZEu bytes( u selfu resu data( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu readall2 s
u RawIOBase.readallc C s | j d d S( u Read up to len(b) bytes into bytearray b.
Returns an int representing the number of bytes read (0 for EOF), or
None if the object is set not to block and has no data to read.
u readintoN( u _unsupported( u selfu b( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu readinto@ s u RawIOBase.readintoc C s | j d d S( u~ Write the given buffer to the IO stream.
Returns the number of bytes written, which may be less than len(b).
u writeN( u _unsupported( u selfu b( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu writeH s u RawIOBase.writeNi( u __name__u
__module__u __qualname__u __doc__u readu readallu readintou write( u
__locals__( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu RawIOBase s
u RawIOBase( u FileIOc B s\ | Ee Z d Z d Z d d d Z d d d Z d d Z d d Z d
d Z d S(
u BufferedIOBaseu Base class for buffered IO objects.
The main difference with RawIOBase is that the read() method
supports omitting the size argument, and does not have a default
implementation that defers to readinto().
In addition, read(), readinto() and write() may raise
BlockingIOError if the underlying raw stream is in non-blocking
mode and not ready; unlike their raw counterparts, they will never
return None.
A typical implementation should not inherit from a RawIOBase
implementation, but wrap one.
c C s | j d d S( u Read and return up to n bytes, where n is an int.
If the argument is omitted, None, or negative, reads and
returns all data until EOF.
If the argument is positive, and the underlying raw stream is
not 'interactive', multiple raw reads may be issued to satisfy
the byte count (unless EOF is reached first). But for
interactive raw streams (XXX and for pipes?), at most one raw
read will be issued, and a short result does not imply that
EOF is imminent.
Returns an empty bytes array on EOF.
Raises BlockingIOError if the underlying raw stream has no
data at the moment.
u readN( u _unsupported( u selfu n( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu reade s u BufferedIOBase.readc C s | j d d S( u[ Read up to n bytes with at most one read() system call,
where n is an int.
u read1N( u _unsupported( u selfu n( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu read1y s u BufferedIOBase.read1c C s | j t | } t | } y | | d | | j d k r t d n | j | j } d | _ | S( Nu raw stream already detached( u rawu Noneu
ValueErroru flushu _raw( u selfu raw( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu detach s
u _BufferedIOMixin.detachc C s
| j j S( N( u rawu seekable( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu seekable s u _BufferedIOMixin.seekablec C s
| j j S( N( u rawu readable( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu readable s u _BufferedIOMixin.readablec C s
| j j S( N( u rawu writable( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu writable s u _BufferedIOMixin.writablec C s | j S( N( u _raw( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu raw s u _BufferedIOMixin.rawc C s
| j j S( N( u rawu closed( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu closed s u _BufferedIOMixin.closedc C s
| j j S( N( u rawu name( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu name s u _BufferedIOMixin.namec C s
| j j S( N( u rawu mode( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu mode s u _BufferedIOMixin.modec C s t d j | j j d S( Nu can not serialize a '{0}' object( u TypeErroru formatu __class__u __name__( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __getstate__ s u _BufferedIOMixin.__getstate__c C sO | j j } y
| j } Wn t k
r: d j | SYn Xd j | | Sd S( Nu <_pyio.{0}>u <_pyio.{0} name={1!r}>( u __class__u __name__u nameu AttributeErroru format( u selfu clsnameu name( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __repr__ s
u _BufferedIOMixin.__repr__c C s
| j j S( N( u rawu fileno( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu fileno s u _BufferedIOMixin.filenoc C s
| j j S( N( u rawu isatty( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu isatty s u _BufferedIOMixin.isattyN( u __name__u
__module__u __qualname__u __doc__u __init__u seeku tellu Noneu truncateu flushu closeu detachu seekableu readableu writableu propertyu rawu closedu nameu modeu __getstate__u __repr__u filenou isatty( u
__locals__( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu _BufferedIOMixin s&
u _BufferedIOMixinc B s | Ee Z d Z d Z d d d Z d d Z d d Z d d Z d d
d Z d d
Z
d d Z d d d Z d d Z
d d d Z d d Z d d Z d d Z d S( u BytesIOu< Buffered I/O implementation using an in-memory bytes buffer.c C s8 t } | d k r" | | 7} n | | _ d | _ d S( Ni ( u bytearrayu Noneu _bufferu _pos( u selfu
initial_bytesu buf( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __init__ s
u BytesIO.__init__c C s% | j r t d n | j j S( Nu __getstate__ on closed file( u closedu
ValueErroru __dict__u copy( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __getstate__& s u BytesIO.__getstate__c C s% | j r t d n t | j S( u8 Return the bytes value (contents) of the buffer
u getvalue on closed file( u closedu
ValueErroru bytesu _buffer( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu getvalue+ s u BytesIO.getvaluec C s
t | j S( u; Return a readable and writable view of the buffer.
( u
memoryviewu _buffer( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu getbuffer2 s u BytesIO.getbufferc C s | j r t d n | d k r- d } n | d k rK t | j } n t | j | j k rg d St t | j | j | } | j | j | } | | _ t | S( Nu read from closed filei i s i( u closedu
ValueErroru Noneu lenu _bufferu _posu minu bytes( u selfu nu newposu b( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu read7 s u BytesIO.readc C s
| j | S( u" This is the same as read.
( u read( u selfu n( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu read1E s u
BytesIO.read1c C s | j r t d n t | t r6 t d n t | } | d k rR d S| j } | t | j k r d | t | j } | j | 7_ n | | j | | | <| j | 7_ | S( Nu write to closed fileu can't write str to binary streami s ( u closedu
ValueErroru
isinstanceu stru TypeErroru lenu _posu _buffer( u selfu bu nu posu padding( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu writeJ s u
BytesIO.writei c C s | j r t d n y | j Wn4 t k
rY } z t d | WYd d } ~ Xn X| d k r | d k r t d | f n | | _ nb | d k r t d | j | | _ n: | d k r t d t | j | | _ n t d | j S( Nu seek on closed fileu an integer is requiredi u negative seek position %ri i u unsupported whence value( u closedu
ValueErroru __index__u AttributeErroru TypeErroru _posu maxu lenu _buffer( u selfu posu whenceu err( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu seek\ s " " u BytesIO.seekc C s | j r t d n | j S( Nu tell on closed file( u closedu
ValueErroru _pos( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu tello s u BytesIO.tellc C s | j r t d n | d k r0 | j } nd y | j Wn4 t k
rq } z t d | WYd d } ~ Xn X| d k r t d | f n | j | d =| S( Nu truncate on closed fileu an integer is requiredi u negative truncate position %r( u closedu
ValueErroru Noneu _posu __index__u AttributeErroru TypeErroru _buffer( u selfu posu err( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu truncatet s " u BytesIO.truncatec C s | j r t d n d S( Nu I/O operation on closed file.T( u closedu
ValueErroru True( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu readable s u BytesIO.readablec C s | j r t d n d S( Nu I/O operation on closed file.T( u closedu
ValueErroru True( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu writable s u BytesIO.writablec C s | j r t d n d S( Nu I/O operation on closed file.T( u closedu
ValueErroru True( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu seekable s u BytesIO.seekableN( u __name__u
__module__u __qualname__u __doc__u Noneu __init__u __getstate__u getvalueu getbufferu readu read1u writeu seeku tellu truncateu readableu writableu seekable( u
__locals__( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu BytesIO s u BytesIOc B s | Ee Z d Z d Z e d d Z d d Z d d d Z d d d Z d
d d Z
d
d
d Z d d Z d d Z
d
d d Z d S( u BufferedReaderu BufferedReader(raw[, buffer_size])
A buffer for a readable, sequential BaseRawIO object.
The constructor creates a BufferedReader for the given readable raw
stream and buffer_size. If buffer_size is omitted, DEFAULT_BUFFER_SIZE
is used.
c C si | j s t d n t j | | | d k rF t d n | | _ | j t | _ d S( uM Create a new buffered reader using the given readable raw IO object.
u "raw" argument must be readable.i u invalid buffer sizeN( u readableu IOErroru _BufferedIOMixinu __init__u
ValueErroru buffer_sizeu _reset_read_bufu Locku
_read_lock( u selfu rawu buffer_size( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __init__ s
u BufferedReader.__init__c C s d | _ d | _ d S( Ns i ( u _read_bufu _read_pos( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu _reset_read_buf s u BufferedReader._reset_read_bufc
C sH | d k r' | d k r' t d n | j | j | SWd QXd S( u Read n bytes.
Returns exactly n bytes of data unless the underlying raw IO
stream reaches EOF or if the call would block in non-blocking
mode. If n is negative, read until EOF or until read() would
block.
i u invalid number of bytes to readNi( u Noneu
ValueErroru
_read_locku _read_unlocked( u selfu n( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu read s
u BufferedReader.readc C sN d } d } | j } | j } | d k s6 | d k r&| j t | j d r | j j } | d k r | | d p d S| | d | Sn | | d g } d } xa y | j j } Wn t k
r w Yn X| | k r | } Pn | t | 7} | j
| q d j | p%| St | | } | | k rc| j | 7_ | | | | S| | d g } t | j
| }
xq | | k ry | j j |
} Wn t k
rwYn X| | k r| } Pn | t | 7} | j
| qWt | | } d j | } | | d | _ d | _ | rJ| d | S| S( Ns i u readalli ( s Ni( u Noneu _read_bufu _read_posu _reset_read_bufu hasattru rawu readallu readu InterruptedErroru lenu appendu joinu maxu buffer_sizeu min( u selfu nu
nodata_valu empty_valuesu bufu posu chunku chunksu current_sizeu availu wantedu out( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu _read_unlocked sZ
u BufferedReader._read_unlockedi c C s! | j | j | SWd QXd S( u Returns buffered bytes without advancing the position.
The argument indicates a desired minimal number of bytes; we
do at most one raw read to satisfy it. We never return more
than self.buffer_size.
N( u
_read_locku _peek_unlocked( u selfu n( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu peek s
u BufferedReader.peekc C s t | | j } t | j | j } | | k s@ | d k r | j | } x2 y | j j | } Wn t k
r} wP Yn XPqP | r | j | j d | | _ d | _ q n | j | j d S( Ni ( u minu buffer_sizeu lenu _read_bufu _read_posu rawu readu InterruptedError( u selfu nu wantu haveu to_readu current( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu _peek_unlocked s
u BufferedReader._peek_unlockedc C sr | d k r t d n | d k r+ d S| j 8 | j d | j t | t | j | j SWd QXd S( u9 Reads up to n bytes, with at most one read() system call.i u( number of bytes to read must be positives i N( u
ValueErroru
_read_locku _peek_unlockedu _read_unlockedu minu lenu _read_bufu _read_pos( u selfu n( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu read1 s
u BufferedReader.read1c C s! t j | t | j | j S( N( u _BufferedIOMixinu tellu lenu _read_bufu _read_pos( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu tell s u BufferedReader.tellc C s{ | t k r t d n | j Q | d k rN | t | j | j 8} n t j | | | } | j | SWd QXd S( Nu invalid whence valuei ( u valid_seek_flagsu
ValueErroru
_read_locku lenu _read_bufu _read_posu _BufferedIOMixinu seeku _reset_read_buf( u selfu posu whence( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu seek s
u BufferedReader.seekN( u __name__u
__module__u __qualname__u __doc__u DEFAULT_BUFFER_SIZEu __init__u _reset_read_bufu Noneu readu _read_unlockedu peeku _peek_unlockedu read1u tellu seek( u
__locals__( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu BufferedReader s
:
u BufferedReaderc B sw | Ee Z d Z d Z e d d Z d d Z d d d Z d d Z d
d Z
d d
Z d d d Z d S( u BufferedWriteru A buffer for a writeable sequential RawIO object.
The constructor creates a BufferedWriter for the given writeable raw
stream. If the buffer_size is not given, it defaults to
DEFAULT_BUFFER_SIZE.
c C sk | j s t d n t j | | | d k rF t d n | | _ t | _ t | _ d S( Nu "raw" argument must be writable.i u invalid buffer size(
u writableu IOErroru _BufferedIOMixinu __init__u
ValueErroru buffer_sizeu bytearrayu
_write_bufu Locku _write_lock( u selfu rawu buffer_size( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __init__3 s u BufferedWriter.__init__c C sb | j r t d n t | t r6 t d n | j t | j | j k re | j n t | j } | j j
| t | j | } t | j | j k rTy | j WqTt k
rP} zq t | j | j k r>t | j | j } | | 8} | j d | j | _ t | j | j
| n WYd d } ~ XqTXn | SWd QXd S( Nu write to closed fileu can't write str to binary stream( u closedu
ValueErroru
isinstanceu stru TypeErroru _write_locku lenu
_write_bufu buffer_sizeu _flush_unlockedu extendu BlockingIOErroru errnou strerror( u selfu bu beforeu writtenu eu overage( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu write> s(
1u BufferedWriter.writec C sL | j = | j | d k r2 | j j } n | j j | SWd QXd S( N( u _write_locku _flush_unlockedu Noneu rawu tellu truncate( u selfu pos( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu truncateZ s
u BufferedWriter.truncatec C s | j | j Wd QXd S( N( u _write_locku _flush_unlocked( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu flusha s
u BufferedWriter.flushc C s | j r t d n x | j r y | j j | j } Wn2 t k
rT w Yn t k
rq t d Yn X| d k r t t j
d d n | t | j k s | d k r t d n | j d | =q Wd S( Nu flush of closed fileuH self.raw should implement RawIOBase: it should not raise BlockingIOErroru) write could not complete without blockingi u* write() returned incorrect number of bytes(
u closedu
ValueErroru
_write_bufu rawu writeu InterruptedErroru BlockingIOErroru RuntimeErroru Noneu errnou EAGAINu lenu IOError( u selfu n( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu _flush_unlockede s
!u BufferedWriter._flush_unlockedc C s t j | t | j S( N( u _BufferedIOMixinu tellu lenu
_write_buf( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu tellx s u BufferedWriter.telli c C sL | t k r t d n | j " | j t j | | | SWd QXd S( Nu invalid whence value( u valid_seek_flagsu
ValueErroru _write_locku _flush_unlockedu _BufferedIOMixinu seek( u selfu posu whence( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu seek{ s
u BufferedWriter.seekN(
u __name__u
__module__u __qualname__u __doc__u DEFAULT_BUFFER_SIZEu __init__u writeu Noneu truncateu flushu _flush_unlockedu tellu seek( u
__locals__( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu BufferedWriter* s u BufferedWriterc B s | Ee Z d Z d Z e d d Z d d d Z d d Z d d Z d
d d Z
d
d Z d d Z d d Z
d d Z d d Z d d Z e d d Z d S( u BufferedRWPairu A buffered reader and writer object together.
A buffered reader object and buffered writer object put together to
form a sequential IO object that can read and write. This is typically
used with a socket or two-way pipe.
reader and writer are RawIOBase objects that are readable and
writeable respectively. If the buffer_size is omitted it defaults to
DEFAULT_BUFFER_SIZE.
c C s^ | j s t d n | j s6 t d n t | | | _ t | | | _ d S( uE Constructor.
The arguments are two RawIO instances.
u# "reader" argument must be readable.u# "writer" argument must be writable.N( u readableu IOErroru writableu BufferedReaderu readeru BufferedWriteru writer( u selfu readeru writeru buffer_size( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __init__ s u BufferedRWPair.__init__c C s% | d k r d } n | j j | S( Ni i( u Noneu readeru read( u selfu n( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu read s u BufferedRWPair.readc C s | j j | S( N( u readeru readinto( u selfu b( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu readinto s u BufferedRWPair.readintoc C s | j j | S( N( u writeru write( u selfu b( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu write s u BufferedRWPair.writei c C s | j j | S( N( u readeru peek( u selfu n( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu peek s u BufferedRWPair.peekc C s | j j | S( N( u readeru read1( u selfu n( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu read1 s u BufferedRWPair.read1c C s
| j j S( N( u readeru readable( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu readable s u BufferedRWPair.readablec C s
| j j S( N( u writeru writable( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu writable s u BufferedRWPair.writablec C s
| j j S( N( u writeru flush( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu flush s u BufferedRWPair.flushc C s | j j | j j d S( N( u writeru closeu reader( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu close s
u BufferedRWPair.closec C s | j j p | j j S( N( u readeru isattyu writer( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu isatty s u BufferedRWPair.isattyc C s
| j j S( N( u writeru closed( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu closed s u BufferedRWPair.closedN( u __name__u
__module__u __qualname__u __doc__u DEFAULT_BUFFER_SIZEu __init__u Noneu readu readintou writeu peeku read1u readableu writableu flushu closeu isattyu propertyu closed( u
__locals__( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu BufferedRWPair s u BufferedRWPairc B s | Ee Z d Z d Z e d d Z d d d Z d d Z d d d
Z d d d Z
d
d Z d d d Z d d Z
d d Z d S( u BufferedRandomu A buffered interface to random access streams.
The constructor creates a reader and writer for a seekable stream,
raw, given in the first argument. If the buffer_size is omitted it
defaults to DEFAULT_BUFFER_SIZE.
c C s4 | j t j | | | t j | | | d S( N( u _checkSeekableu BufferedReaderu __init__u BufferedWriter( u selfu rawu buffer_size( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __init__ s
u BufferedRandom.__init__i c C s | t k r t d n | j | j rd | j ( | j j | j t | j d Wd QXn | j j | | } | j | j Wd QX| d k r t
d n | S( Nu invalid whence valuei i u seek() returned invalid position( u valid_seek_flagsu
ValueErroru flushu _read_bufu
_read_locku rawu seeku _read_posu lenu _reset_read_bufu IOError( u selfu posu whence( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu seek s
,
u BufferedRandom.seekc C s' | j r t j | St j | Sd S( N( u
_write_bufu BufferedWriteru tellu BufferedReader( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu tell s
u BufferedRandom.tellc C s+ | d k r | j } n t j | | S( N( u Noneu tellu BufferedWriteru truncate( u selfu pos( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu truncate s u BufferedRandom.truncatec C s/ | d k r d } n | j t j | | S( Ni i( u Noneu flushu BufferedReaderu read( u selfu n( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu read s
u BufferedRandom.readc C s | j t j | | S( N( u flushu BufferedReaderu readinto( u selfu b( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu readinto s
u BufferedRandom.readintoc C s | j t j | | S( N( u flushu BufferedReaderu peek( u selfu n( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu peek s
u BufferedRandom.peekc C s | j t j | | S( N( u flushu BufferedReaderu read1( u selfu n( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu read1 s
u BufferedRandom.read1c C sY | j rI | j 2 | j j | j t | j d | j Wd QXn t j | | S( Ni ( u _read_bufu
_read_locku rawu seeku _read_posu lenu _reset_read_bufu BufferedWriteru write( u selfu b( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu write s
#u BufferedRandom.writeN( u __name__u
__module__u __qualname__u __doc__u DEFAULT_BUFFER_SIZEu __init__u seeku tellu Noneu truncateu readu readintou peeku read1u write( u
__locals__( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu BufferedRandom s u BufferedRandomc B s | Ee Z d Z d Z d d d Z d d Z d d d Z d d
Z d d Z e
d
d Z e
d d Z e
d d Z
d S( u
TextIOBaseu Base class for text I/O.
This class provides a character and line based interface to stream
I/O. There is no readinto method because Python's character strings
are immutable. There is no public constructor.
i c C s | j d d S( u Read at most n characters from stream, where n is an int.
Read from underlying buffer until we have n characters or we hit EOF.
If n is negative or omitted, read until EOF.
Returns a string.
u readN( u _unsupported( u selfu n( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu read s u TextIOBase.readc C s | j d d S( u. Write string s to stream and returning an int.u writeN( u _unsupported( u selfu s( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu write s u TextIOBase.writec C s | j d d S( u* Truncate size to pos, where pos is an int.u truncateN( u _unsupported( u selfu pos( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu truncate$ s u TextIOBase.truncatec C s | j d d S( u_ Read until newline or EOF.
Returns an empty string if EOF is hit immediately.
u readlineN( u _unsupported( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu readline( s u TextIOBase.readlinec C s | j d d S( u
Separate the underlying buffer from the TextIOBase and return it.
After the underlying buffer has been detached, the TextIO is in an
unusable state.
u detachN( u _unsupported( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu detach/ s u TextIOBase.detachc C s d S( u Subclasses should override.N( u None( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu encoding8 s u TextIOBase.encodingc C s d S( u Line endings translated so far.
Only line endings translated during reading are considered.
Subclasses should override.
N( u None( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu newlines= s u TextIOBase.newlinesc C s d S( uM Error setting of the decoder or encoder.
Subclasses should override.N( u None( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu errorsG s u TextIOBase.errorsNi( u __name__u
__module__u __qualname__u __doc__u readu writeu Noneu truncateu readlineu detachu propertyu encodingu newlinesu errors( u
__locals__( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu
TextIOBase
s
u
TextIOBasec B s | Ee Z d Z d Z d d d Z d d d Z d d Z d d
Z d d Z d
Z
d Z d Z e
d d Z d S( u IncrementalNewlineDecoderu+ Codec used when reading a file in universal newlines mode. It wraps
another incremental decoder, translating \r\n and \r into \n. It also
records the types of newlines encountered. When used with
translate=False, it ensures that the newline sequence is returned in
one piece.
u strictc C s> t j j | d | | | _ | | _ d | _ d | _ d S( Nu errorsi F( u codecsu IncrementalDecoderu __init__u translateu decoderu seennlu Falseu pendingcr( u selfu decoderu translateu errors( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __init__X s
u" IncrementalNewlineDecoder.__init__c
C s: | j d k r | } n | j j | d | } | j r[ | sE | r[ d | } d | _ n | j d r | r | d d } d | _ n | j d } | j d | } | j d | } | j | o | j | o | j
B| o | j BO_ | j r6| r| j
d d } n | r6| j
d d } q6n | S( Nu finalu
i u
u
FiT( u decoderu Noneu decodeu pendingcru Falseu endswithu Trueu countu seennlu _LFu _CRu _CRLFu translateu replace( u selfu inputu finalu outputu crlfu cru lf( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu decode_ s(
+ u IncrementalNewlineDecoder.decodec C s] | j d k r d } d } n | j j \ } } | d K} | j rS | d O} n | | f S( Ns i i ( u decoderu Noneu getstateu pendingcr( u selfu bufu flag( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu getstate~ s
u" IncrementalNewlineDecoder.getstatec C sO | \ } } t | d @ | _ | j d k rK | j j | | d ?f n d S( Ni ( u boolu pendingcru decoderu Noneu setstate( u selfu stateu bufu flag( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu setstate s u" IncrementalNewlineDecoder.setstatec C s5 d | _ d | _ | j d k r1 | j j n d S( Ni F( u seennlu Falseu pendingcru decoderu Noneu reset( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu reset s u IncrementalNewlineDecoder.reseti i i c
C s d | j S( Nu
u
u
( u
u
( u
u
( u
u
( u
u
u
( Nu
u
( u
u
u
( u
u
( u
u
( u
u
u
( u Noneu seennl( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu newlines s u" IncrementalNewlineDecoder.newlinesNF( u __name__u
__module__u __qualname__u __doc__u __init__u Falseu decodeu getstateu setstateu resetu _LFu _CRu _CRLFu propertyu newlines( u
__locals__( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu IncrementalNewlineDecoderQ s u IncrementalNewlineDecoderc B s | Ee Z d Z d Z d Z dD dD dD dE dE d d Z d d Z e d d Z
e d d
Z e d d Z e d
d Z
d d Z d d Z d d Z d d Z d d Z e d d Z e d d Z d d Z d d Z d! d" Z d# d$ Z d% d& Z d' d( Z dD d) d* Z d+ d, Z d- d. Z d/ d/ d/ d/ d0 d1 Z d2 d3 Z d4 d5 Z dD d6 d7 Z! d8 d9 Z" d/ d: d; Z# dD d< d= Z$ d> d? Z% dD d@ dA Z& e dB dC Z' dD S(F u
TextIOWrapperu Character and line based layer over a BufferedIOBase object, buffer.
encoding gives the name of the encoding that the stream will be
decoded or encoded with. It defaults to locale.getpreferredencoding(False).
errors determines the strictness of encoding and decoding (see the
codecs.register) and defaults to "strict".
newline can be None, '', '\n', '\r', or '\r\n'. It controls the
handling of line endings. If it is None, universal newlines is
enabled. With this enabled, on input, the lines endings '\n', '\r',
or '\r\n' are translated to '\n' before being returned to the
caller. Conversely, on output, '\n' is translated to the system
default line separator, os.linesep. If newline is any other of its
legal values, that newline becomes the newline when the file is read
and it is returned untranslated. On output, '\n' is converted to the
newline.
If line_buffering is True, a call to flush is implied when a call to
write contains a newline character.
i c
C s | d k r8 t | t r8 t d t | f n | d k rZ t d | f n | d k r y t j | j } Wn t t
f k
r Yn X| d k r y d d l } Wn t k
r d } Yq X| j
d } q n t | t st d | n t j | j s3d
} t | | n | d k rHd } n" t | t sjt d | n | | _ | | _ | | _ | | _ | | _ | d k | _ | | _ | d k | _ | pt j | _ d | _ d | _ d | _ d | _ d | _! | j" j# | _$ | _% t& | j" d
| _' d | _( | j$ r| j) r| j" j* } | d k ry | j+ j, d Wqt k
rYqXqn d S( Nu illegal newline type: %ru u
u
u
u illegal newline value: %ri u asciiu invalid encoding: %ruG %r is not a text encoding; use codecs.open() to handle arbitrary codecsu strictu invalid errors: %ru read1g ( Nu u
u
u
F(- u Noneu
isinstanceu stru TypeErroru typeu
ValueErroru osu device_encodingu filenou AttributeErroru UnsupportedOperationu localeu ImportErroru getpreferredencodingu Falseu codecsu lookupu _is_text_encodingu LookupErroru _bufferu _line_bufferingu _encodingu _errorsu _readuniversalu _readtranslateu _readnlu _writetranslateu linesepu _writenlu _encoderu _decoderu _decoded_charsu _decoded_chars_usedu _snapshotu bufferu seekableu _seekableu _tellingu hasattru
_has_read1u _b2cratiou writableu tellu _get_encoderu setstate(
u selfu bufferu encodingu errorsu newlineu line_bufferingu
write_throughu localeu msgu position( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __init__ s`
u TextIOWrapper.__init__c C s d } y
| j } Wn t k
r' Yn X| d j | 7} y
| j } Wn t k
r\ Yn X| d j | 7} | d j | j S( Nu <_pyio.TextIOWrapperu name={0!r}u mode={0!r}u encoding={0!r}>( u nameu AttributeErroru formatu modeu encoding( u selfu resultu nameu mode( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __repr__ s
u TextIOWrapper.__repr__c C s | j S( N( u _encoding( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu encoding s u TextIOWrapper.encodingc C s | j S( N( u _errors( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu errors s u TextIOWrapper.errorsc C s | j S( N( u _line_buffering( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu line_buffering! s u TextIOWrapper.line_bufferingc C s | j S( N( u _buffer( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu buffer% s u TextIOWrapper.bufferc C s | j r t d n | j S( Nu I/O operation on closed file.( u closedu
ValueErroru _seekable( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu seekable) s u TextIOWrapper.seekablec C s
| j j S( N( u bufferu readable( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu readable. s u TextIOWrapper.readablec C s
| j j S( N( u bufferu writable( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu writable1 s u TextIOWrapper.writablec C s | j j | j | _ d S( N( u bufferu flushu _seekableu _telling( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu flush4 s
u TextIOWrapper.flushc C s? | j d k r; | j r; z | j Wd | j j Xn d S( N( u bufferu Noneu closedu flushu close( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu close8 s u TextIOWrapper.closec C s
| j j S( N( u bufferu closed( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu closed? s u TextIOWrapper.closedc C s
| j j S( N( u bufferu name( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu nameC s u TextIOWrapper.namec C s
| j j S( N( u bufferu fileno( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu filenoG s u TextIOWrapper.filenoc C s
| j j S( N( u bufferu isatty( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu isattyJ s u TextIOWrapper.isattyc C s" | j r t d n t | t s@ t d | j j n t | } | j s^ | j og d | k } | r | j r | j
d k r | j d | j
} n | j p | j
} | j | } | j j | | j r | s d | k r | j n d | _ | j r | j j n | S( u Write data, where s is a stru write to closed fileu can't write %s to text streamu
u
N( u closedu
ValueErroru
isinstanceu stru TypeErroru __class__u __name__u lenu _writetranslateu _line_bufferingu _writenlu replaceu _encoderu _get_encoderu encodeu bufferu writeu flushu Noneu _snapshotu _decoderu reset( u selfu su lengthu haslfu encoderu b( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu writeM s$
u TextIOWrapper.writec C s+ t j | j } | | j | _ | j S( N( u codecsu getincrementalencoderu _encodingu _errorsu _encoder( u selfu make_encoder( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu _get_encoderc s u TextIOWrapper._get_encoderc C sL t j | j } | | j } | j r? t | | j } n | | _ | S( N( u codecsu getincrementaldecoderu _encodingu _errorsu _readuniversalu IncrementalNewlineDecoderu _readtranslateu _decoder( u selfu make_decoderu decoder( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu _get_decoderh s u TextIOWrapper._get_decoderc C s | | _ d | _ d S( u Set the _decoded_chars buffer.i N( u _decoded_charsu _decoded_chars_used( u selfu chars( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu _set_decoded_charss s u TextIOWrapper._set_decoded_charsc C s[ | j } | d k r+ | j | d } n | j | | | } | j t | 7_ | S( u' Advance into the _decoded_chars buffer.N( u _decoded_chars_usedu Noneu _decoded_charsu len( u selfu nu offsetu chars( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu _get_decoded_charsx s u TextIOWrapper._get_decoded_charsc C s1 | j | k r t d n | j | 8_ d S( u! Rewind the _decoded_chars buffer.u" rewind decoded_chars out of boundsN( u _decoded_chars_usedu AssertionError( u selfu n( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu _rewind_decoded_chars s u# TextIOWrapper._rewind_decoded_charsc C s | j d k r t d n | j r? | j j \ } } n | j r` | j j | j } n | j j | j } | } | j j
| | } | j | | r t | t | j
| _ n d | _ | j r | | | f | _ n | S( uQ
Read and decode the next chunk of data from the BufferedReader.
u
no decoderg N( u _decoderu Noneu
ValueErroru _tellingu getstateu
_has_read1u bufferu read1u _CHUNK_SIZEu readu decodeu _set_decoded_charsu lenu _decoded_charsu _b2cratiou _snapshot( u selfu
dec_bufferu dec_flagsu input_chunku eofu
decoded_chars( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu _read_chunk s
u TextIOWrapper._read_chunki c C s* | | d >B| d >B| d >Bt | d >BS( Ni@ i i i ( u bool( u selfu positionu dec_flagsu
bytes_to_feedu need_eofu
chars_to_skip( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu _pack_cookie s u TextIOWrapper._pack_cookiec C sg t | d \ } } t | d \ } } t | d \ } } t | d \ } } | | | | | f S( Ni i@ l l l l ( u divmod( u selfu bigintu restu positionu dec_flagsu
bytes_to_feedu need_eofu
chars_to_skip( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu _unpack_cookie s
u TextIOWrapper._unpack_cookiec C s | j s t d n | j s0 t d n | j | j j } | j } | d k sm | j d k r | j
r t d n | S| j \ } } | t | 8} | j
} | d k r | j | | S| j } z(t | j | } d } x | d k r| j d | f t | j | d | } | | k r| j \ }
} |
sn| } | | 8} Pn | t |
8} d } q | | 8} | d } q Wd } | j d | f | | } | }
| d k r| j | |
Sd } d } d } x t | t | D] } | d 7} | t | j | | | d 7} | j \ } } | r| | k r| | 7} | | 8} | d d }
} } n | | k r Pq q W| t | j d d d
7} d } | | k rt d n | j | |
| | | SWd | j | Xd S( Nu! underlying stream is not seekableu( telling position disabled by next() callu pending decoded texti i s i u finalu' can't reconstruct logical file positionT( u _seekableu UnsupportedOperationu _tellingu IOErroru flushu bufferu tellu _decoderu Noneu _snapshotu _decoded_charsu AssertionErroru lenu _decoded_chars_usedu _pack_cookieu getstateu intu _b2cratiou setstateu decodeu rangeu True( u selfu positionu decoderu dec_flagsu
next_inputu
chars_to_skipu saved_stateu
skip_bytesu skip_backu nu bu du start_posu start_flagsu bytes_fedu need_eofu
chars_decodedu iu
dec_buffer( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu tell sv
'
u TextIOWrapper.tellc C s5 | j | d k r% | j } n | j j | S( N( u flushu Noneu tellu bufferu truncate( u selfu pos( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu truncate& s
u TextIOWrapper.truncatec C s> | j d k r t d n | j | j } d | _ | S( Nu buffer is already detached( u bufferu Noneu
ValueErroru flushu _buffer( u selfu buffer( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu detach, s
u TextIOWrapper.detachc C s | j r t d n | j s0 t d n | d k rl | d k rW t d n d } | j } n | d k r | d k r t d n | j | j j d d } | j d d | _
| j r | j j n | S| d k rt d | f n | d k r)t d
| f n | j | j
| \ } } } } } | j j | | j d d | _
| d k r| j r| j j nU | j s| s| r| j p| j | _ | j j d | f | d f | _
n | rd| j j | } | j | j j | | | | f | _
t | j | k rXt d n | | _ n y | j py| j }
Wn t k
rYn' X| d k r|
j d n
|
j | S(
Nu tell on closed fileu! underlying stream is not seekablei i u# can't do nonzero cur-relative seeksi u# can't do nonzero end-relative seeksu u unsupported whence (%r)u negative seek position %rs u# can't restore logical file position( u closedu
ValueErroru _seekableu UnsupportedOperationu tellu flushu bufferu seeku _set_decoded_charsu Noneu _snapshotu _decoderu resetu _unpack_cookieu _get_decoderu setstateu readu decodeu lenu _decoded_charsu IOErroru _decoded_chars_usedu _encoderu _get_encoderu LookupError( u selfu cookieu whenceu positionu start_posu dec_flagsu
bytes_to_feedu need_eofu
chars_to_skipu input_chunku encoder( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu seek4 sd
u TextIOWrapper.seekc C s+ | j | d k r d } n | j p1 | j } y | j Wn4 t k
ru } z t d | WYd d } ~ Xn X| d k r | j | j | j j
d d } | j d d | _
| Sd } | j | } xG t | | k r"| r"| j } | | j | t | 7} q W| Sd S( Ni u an integer is requiredi u finalu iTF( u _checkReadableu Noneu _decoderu _get_decoderu __index__u AttributeErroru TypeErroru _get_decoded_charsu decodeu bufferu readu Trueu _set_decoded_charsu _snapshotu Falseu lenu _read_chunk( u selfu nu decoderu erru resultu eof( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu read{ s(
"
!u TextIOWrapper.readc C s= d | _ | j } | s9 d | _ | j | _ t n | S( NF( u Falseu _tellingu readlineu Noneu _snapshotu _seekableu
StopIteration( u selfu line( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __next__ s u TextIOWrapper.__next__c C s | j r t d n | d k r- d } n t | t sK t d n | j } d } | j ss | j n d } } x| j r | j
d | } | d k r | d } Pqt | } n | j r| j
d | } | j
d | } | d
k r&| d k rt | } q| d } Pq| d k r@| d } Pq| | k rZ| d } Pq| | d k rx| d } Pq| d } Pn5 | j
| j
} | d k r| t | j
} Pn | d k rt | | k r| } Pn x | j r| j rPqqW| j r | | j 7} q | j d d | _ | Sq | d k r]| | k r]| } n | j t | | | d | S(
Nu read from closed filei u limit must be an integeri u
u
i u iiii( u closedu
ValueErroru Noneu
isinstanceu intu TypeErroru _get_decoded_charsu _decoderu _get_decoderu _readtranslateu findu lenu _readuniversalu _readnlu _read_chunku _decoded_charsu _set_decoded_charsu _snapshotu _rewind_decoded_chars( u selfu limitu lineu startu posu endposu nlposu crpos( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu readline sp
u TextIOWrapper.readlinec C s | j r | j j Sd S( N( u _decoderu newlinesu None( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu newlines s u TextIOWrapper.newlinesNF(( u __name__u
__module__u __qualname__u __doc__u _CHUNK_SIZEu Noneu Falseu __init__u __repr__u propertyu encodingu errorsu line_bufferingu bufferu seekableu readableu writableu flushu closeu closedu nameu filenou isattyu writeu _get_encoderu _get_decoderu _set_decoded_charsu _get_decoded_charsu _rewind_decoded_charsu _read_chunku _pack_cookieu _unpack_cookieu tellu truncateu detachu seeku readu __next__u readlineu newlines( u
__locals__( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu
TextIOWrapper sH E
* c G Xu
TextIOWrapperc sz | Ee Z d Z d Z d d f d d Z d d Z d d Z e d
d Z e d d
Z d d Z
S( u StringIOu Text I/O implementation using an in-memory buffer.
The initial_value argument sets the value of object. The newline
argument is like the one of TextIOWrapper's constructor.
u u
c s t t | j t d d d d d | | d k rC d | _ n | d k r t | t s t d j
t | j t | } n | j
| | j d n d S( Nu encodingu utf-8u errorsu
surrogatepassu newlineu* initial_value must be str or None, not {0}i F( u superu StringIOu __init__u BytesIOu Noneu Falseu _writetranslateu
isinstanceu stru TypeErroru formatu typeu __name__u writeu seek( u selfu
initial_valueu newline( u __class__( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __init__ s
u StringIO.__init__c C sj | j | j p | j } | j } | j z | j | j j d d SWd | j | Xd S( Nu finalT(
u flushu _decoderu _get_decoderu getstateu resetu decodeu bufferu getvalueu Trueu setstate( u selfu decoderu old_state( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu getvalue s
u StringIO.getvaluec C s
t j | S( N( u objectu __repr__( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu __repr__ s u StringIO.__repr__c C s d S( N( u None( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu errors! s u StringIO.errorsc C s d S( N( u None( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu encoding% s u StringIO.encodingc C s | j d d S( Nu detach( u _unsupported( u self( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu detach) s u StringIO.detach( u __name__u
__module__u __qualname__u __doc__u __init__u getvalueu __repr__u propertyu errorsu encodingu detach( u
__locals__( ( u __class__u* /opt/alt/python33/lib64/python3.3/_pyio.pyu StringIO s
u StringIO(1 u __doc__u osu abcu codecsu errnou _threadu
allocate_locku Locku ImportErroru
_dummy_threadu iou __all__u SEEK_SETu SEEK_CURu SEEK_ENDu valid_seek_flagsu hasattru addu SEEK_HOLEu SEEK_DATAu DEFAULT_BUFFER_SIZEu BlockingIOErroru Noneu Trueu openu
DocDescriptoru OpenWrapperu UnsupportedOperationu AttributeErroru
ValueErroru IOErroru ABCMetau IOBaseu registeru RawIOBaseu _iou FileIOu BufferedIOBaseu _BufferedIOMixinu BytesIOu BufferedReaderu BufferedWriteru BufferedRWPairu BufferedRandomu
TextIOBaseu IncrementalDecoderu IncrementalNewlineDecoderu
TextIOWrapperu StringIO( ( ( u* /opt/alt/python33/lib64/python3.3/_pyio.pyu s\
"
<
VnxYDFAU V