JezK
Edit File: bz2.cpython-33.pyo
� � f)H c @ s d Z d d d d d d g Z d Z d d l Z d d l Z d d l Z y d d l m Z Wn" e k r� d d l m Z Yn Xd d l m Z m Z d Z d Z d Z d Z d Z Gd d � d e j � Z d d e e e d d � Z d d d � Z d d � Z d S( u� Interface to the libbzip2 compression library. This module provides a file interface, classes for incremental (de)compression, and functions for one-shot (de)compression. u BZ2Fileu BZ2Compressoru BZ2Decompressoru openu compressu decompressu% Nadeem Vawda <nadeem.vawda@gmail.com>i N( u RLock( u BZ2Compressoru BZ2Decompressori i i i c B sm | Ee Z d Z d Z d d8 d d d � Z 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 d d � Z d d � Z d d � Z d9 d d � Z d9 d d � Z d d! d" � Z d: d$ d% � Z d; d& d' � Z d( d) � Z d< d* d+ � Z d= d, d- � Z d. d/ � Z d0 d1 � Z d2 d3 � Z d d4 d5 � Z d6 d7 � Z d8 S(> u BZ2Fileu@ A file object providing transparent bzip2 (de)compression. A BZ2File can act as a wrapper for an existing file object, or refer directly to a named file on disk. Note that BZ2File provides a *binary* file interface - data read is returned as bytes, and data to be written should be given as bytes. u ri c C s� t � | _ d | _ d | _ t | _ d | _ d | _ | d k rX t j d t � n d | k oo d k n s� t d � � n | d k r� d } t } t � | _ d | _ d | _ ni | d k r� d } t } t | � | _ n? | d k rd } t } t | � | _ n t d j | � � � t | t t f � rdt j | | � | _ d | _ | | _ n? t | d � s�t | d � r�| | _ | | _ n t d � � d S( u Open a bzip2-compressed file. If filename is a str or bytes object, is gives the name of the file to be opened. Otherwise, it should be a file object, which will be used to read or write the compressed data. mode can be 'r' for reading (default), 'w' for (over)writing, or 'a' for appending. These can equivalently be given as 'rb', 'wb', and 'ab'. buffering is ignored. Its use is deprecated. If mode is 'w' or 'a', compresslevel can be a number between 1 and 9 specifying the level of compression: 1 produces the least compression, and 9 (default) produces the most compression. If mode is 'r', the input file may be the concatenation of multiple compressed streams. i i u) Use of 'buffering' argument is deprecatedi u% compresslevel must be between 1 and 9u u ru rbs u wu wbu au abu Invalid mode: {!r}u readu writeu1 filename must be a str or bytes object, or a fileNFi����( u u ru rb( u wu wb( u au abT( u RLocku _locku Noneu _fpu Falseu _closefpu _MODE_CLOSEDu _modeu _posu _sizeu warningsu warnu DeprecationWarningu ValueErroru _MODE_READu BZ2Decompressoru _decompressoru _bufferu _buffer_offsetu _MODE_WRITEu BZ2Compressoru _compressoru formatu isinstanceu stru bytesu builtinsu openu Trueu hasattru TypeError( u selfu filenameu modeu bufferingu compresslevelu mode_code( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu __init__+ sD u BZ2File.__init__c C s� | j �� | j t k r d SzY | j t t f k rA d | _ n4 | j t k ru | j j | j j � � d | _ n Wd z | j r� | j j � n Wd d | _ d | _ t | _ d | _ d | _ XXWd QXd S( u� Flush and close the file. May be called more than once without error. Once the file is closed, any other operation on it will raise a ValueError. Ns i F( u _locku _modeu _MODE_CLOSEDu _MODE_READu _MODE_READ_EOFu Noneu _decompressoru _MODE_WRITEu _fpu writeu _compressoru flushu _closefpu closeu Falseu _bufferu _buffer_offset( u self( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu closei s" u BZ2File.closec C s | j t k S( u True if this file is closed.( u _modeu _MODE_CLOSED( u self( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu closed� s u BZ2File.closedc C s | j � | j j � S( u3 Return the file descriptor for the underlying file.( u _check_not_closedu _fpu fileno( u self( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu fileno� s u BZ2File.filenoc C s | j � o | j j � S( u) Return whether the file supports seeking.( u readableu _fpu seekable( u self( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu seekable� s u BZ2File.seekablec C s | j � | j t t f k S( u/ Return whether the file was opened for reading.( u _check_not_closedu _modeu _MODE_READu _MODE_READ_EOF( u self( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu readable� s u BZ2File.readablec C s | j � | j t k S( u/ Return whether the file was opened for writing.( u _check_not_closedu _modeu _MODE_WRITE( u self( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu writable� s u BZ2File.writablec C s | j r t d � � n d S( Nu I/O operation on closed file( u closedu ValueError( u self( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu _check_not_closed� s u BZ2File._check_not_closedc C s5 | j t t f k r1 | j � t j d � � n d S( Nu File not open for reading( u _modeu _MODE_READu _MODE_READ_EOFu _check_not_closedu iou UnsupportedOperation( u self( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu _check_can_read� s u BZ2File._check_can_readc C s/ | j t k r+ | j � t j d � � n d S( Nu File not open for writing( u _modeu _MODE_WRITEu _check_not_closedu iou UnsupportedOperation( u self( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu _check_can_write� s u BZ2File._check_can_writec C sV | j t t f k r1 | j � t j d � � n | j j � sR t j d � � n d S( Nu3 Seeking is only supported on files open for readingu3 The underlying file object does not support seeking( u _modeu _MODE_READu _MODE_READ_EOFu _check_not_closedu iou UnsupportedOperationu _fpu seekable( u self( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu _check_can_seek� s u BZ2File._check_can_seekc C s | j t k r d Sx� | j t | j � k r | j j pI | j j t � } | s� | j j rw t | _ | j | _ d St d � � n | j j r� t � | _ y | j j | � | _ Wq� t k r� t | _ | j | _ d SYq� Xn | j j | � | _ d | _ q Wd S( NuA Compressed file ended before the end-of-stream marker was reachedi FT( u _modeu _MODE_READ_EOFu Falseu _buffer_offsetu lenu _bufferu _decompressoru unused_datau _fpu readu _BUFFER_SIZEu eofu _posu _sizeu EOFErroru BZ2Decompressoru decompressu OSErroru True( u selfu rawblock( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu _fill_buffer� s, u BZ2File._fill_bufferc C s� | j | j d � | _ d | _ g } xJ | j � rt | rP | j | j � n | j t | j � 7_ d | _ q+ W| r� d j | � Sd S( Ni s ( u _bufferu _buffer_offsetu _fill_bufferu appendu _posu lenu join( u selfu return_datau blocks( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu _read_all� s u BZ2File._read_allc C sC | j | } | t | j � k rd | j | j | � } | | _ | j t | � 7_ | r` | Sd S| j | j d � | _ d | _ g } x� | d k r+| j � r+| t | j � k r� | j d | � } | | _ n | j } d | _ | r| j | � n | j t | � 7_ | t | � 8} q� W| r?d j | � Sd S( Ni s ( u _buffer_offsetu lenu _bufferu _posu Noneu _fill_bufferu appendu join( u selfu nu return_datau endu datau blocks( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu _read_block� s* u BZ2File._read_blocki c C sB | j �3 | j � | j � s$ d S| j | j d � SWd QXd S( u� Return buffered data without advancing the file position. Always returns at least one byte of data, unless at EOF. The exact number of bytes returned is unspecified. s N( u _locku _check_can_readu _fill_bufferu _bufferu _buffer_offset( u selfu n( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu peek s u BZ2File.peeki c C sQ | j �B | j � | d k r$ d S| d k r: | j � S| j | � SWd QXd S( u� Read up to size uncompressed bytes from the file. If size is negative or omitted, read until EOF is reached. Returns b'' if the file is already at EOF. i s N( u _locku _check_can_readu _read_allu _read_block( u selfu size( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu read s u BZ2File.readc C s� | j �� | j � | d k sE | j t | j � k rI | j � rI d S| d k r� | j | j | j | � } | j t | � 7_ n( | j | j d � } d | _ d | _ | j t | � 7_ | SWd QXd S( u� Read up to size uncompressed bytes, while trying to avoid making multiple reads from the underlying stream. Returns b'' if the file is at EOF. i s N( u _locku _check_can_readu _buffer_offsetu lenu _bufferu _fill_bufferu _pos( u selfu sizeu data( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu read1 s % u BZ2File.read1c C s' | j � t j j | | � SWd QXd S( u_ Read up to len(b) bytes into b. Returns the number of bytes read (0 for EOF). N( u _locku iou BufferedIOBaseu readinto( u selfu b( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu readinto: s u BZ2File.readintoc C s� t | t � s< t | d � s- t d � � n | j � } n | j �� | j � | d k r� | j j d | j � d } | d k r� | j | j | � } | | _ | j t | � 7_ | Sn t j j | | � SWd QXd S( u Read a line of uncompressed bytes from the file. The terminating newline (if present) is retained. If size is non-negative, no more than size bytes will be read (in which case the line may be incomplete). Returns b'' if already at EOF. u __index__u Integer argument expectedi s i N( u isinstanceu intu hasattru TypeErroru __index__u _locku _check_can_readu _bufferu findu _buffer_offsetu _posu lenu iou BufferedIOBaseu readline( u selfu sizeu endu line( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu readlineB s u BZ2File.readlinec C sc t | t � s< t | d � s- t d � � n | j � } n | j � t j j | | � SWd QXd S( u� Read a list of lines of uncompressed bytes from the file. size can be specified to control the number of lines read: no further lines will be read once the total size of the lines read so far equals or exceeds size. u __index__u Integer argument expectedN( u isinstanceu intu hasattru TypeErroru __index__u _locku iou BufferedIOBaseu readlines( u selfu size( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu readlinesY s u BZ2File.readlinesc C s_ | j �P | j � | j j | � } | j j | � | j t | � 7_ t | � SWd QXd S( u� Write a byte string to the file. Returns the number of uncompressed bytes written, which is always len(data). Note that due to buffering, the file on disk may not reflect the data written until close() is called. N( u _locku _check_can_writeu _compressoru compressu _fpu writeu _posu len( u selfu datau compressed( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu writeg s u BZ2File.writec C s' | j � t j j | | � SWd QXd S( u� Write a sequence of byte strings to the file. Returns the number of uncompressed bytes written. seq can be any iterable yielding byte strings. Line separators are not added between the written byte strings. N( u _locku iou BufferedIOBaseu writelines( u selfu seq( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu writelinesu s u BZ2File.writelinesc C sG | j j d d � t | _ d | _ t � | _ d | _ d | _ d S( Ni s ( u _fpu seeku _MODE_READu _modeu _posu BZ2Decompressoru _decompressoru _bufferu _buffer_offset( u self( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu _rewind� s u BZ2File._rewindc C s� | j �� | j � | d k r# no | d k r? | j | } nS | d k r} | j d k rm | j d d � n | j | } n t d j | � � � | | j k r� | j � n | | j 8} | j | d d �| j SWd QXd S( u� Change the file position. The new position is specified by offset, relative to the position indicated by whence. Values for whence are: 0: start of stream (default); offset must not be negative 1: current stream position 2: end of stream; offset must not be positive Returns the new file position. Note that seeking is emulated, so depending on the parameters, this operation may be extremely slow. i i i u return_datau Invalid value for whence: {}NF( u _locku _check_can_seeku _posu _sizeu _read_allu Falseu ValueErroru formatu _rewindu _read_block( u selfu offsetu whence( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu seek� s u BZ2File.seekc C s% | j � | j � | j SWd QXd S( u! Return the current file position.N( u _locku _check_not_closedu _pos( u self( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu tell� s u BZ2File.tellNTi����i����i����i����( u __name__u __module__u __qualname__u __doc__u Noneu __init__u closeu propertyu closedu filenou seekableu readableu writableu _check_not_closedu _check_can_readu _check_can_writeu _check_can_seeku _fill_bufferu Trueu _read_allu _read_blocku peeku readu read1u readintou readlineu readlinesu writeu writelinesu _rewindu seeku tell( u __locals__( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu BZ2File s4 > # *u rbi c C s� d | k r1 d | k r� t d | f � � q� nQ | d k rL t d � � n | d k rg t d � � n | d k r� t d � � n | j d d � } t | | d | �} d | k r� t j | | | | � S| Sd S( u� Open a bzip2-compressed file in binary or text mode. The filename argument can be an actual filename (a str or bytes object), or an existing file object to read from or write to. The mode argument can be "r", "rb", "w", "wb", "a" or "ab" for binary mode, or "rt", "wt" or "at" for text mode. The default mode is "rb", and the default compresslevel is 9. For binary mode, this function is equivalent to the BZ2File constructor: BZ2File(filename, mode, compresslevel). In this case, the encoding, errors and newline arguments must not be provided. For text mode, a BZ2File object is created, and wrapped in an io.TextIOWrapper instance with the specified encoding, error handling behavior, and line ending(s). u tu bu Invalid mode: %ru0 Argument 'encoding' not supported in binary modeu. Argument 'errors' not supported in binary modeu/ Argument 'newline' not supported in binary modeu u compresslevelN( u ValueErroru Noneu replaceu BZ2Fileu iou TextIOWrapper( u filenameu modeu compresslevelu encodingu errorsu newlineu bz_modeu binary_file( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu open� s c C s# t | � } | j | � | j � S( u� Compress a block of data. compresslevel, if given, must be a number between 1 and 9. For incremental compression, use a BZ2Compressor object instead. ( u BZ2Compressoru compressu flush( u datau compresslevelu comp( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu compress� s c C s� g } xv | r~ t � } y | j | � } Wn t k rL | rE Pn � Yn X| j | � | j sr t d � � n | j } q Wd j | � S( uj Decompress a block of data. For incremental decompression, use a BZ2Decompressor object instead. uA Compressed data ended before the end-of-stream marker was reacheds ( u BZ2Decompressoru decompressu OSErroru appendu eofu ValueErroru unused_datau join( u datau resultsu decompu res( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu decompress� s ( u __doc__u __all__u __author__u builtinsu iou warningsu threadingu RLocku ImportErroru dummy_threadingu _bz2u BZ2Compressoru BZ2Decompressoru _MODE_CLOSEDu _MODE_READu _MODE_READ_EOFu _MODE_WRITEu _BUFFER_SIZEu BufferedIOBaseu BZ2Fileu Noneu openu compressu decompress( ( ( u( /opt/alt/python33/lib64/python3.3/bz2.pyu <module> s, � �'