HEX
Server: Apache/2.4.52 (Ubuntu)
System: Linux spn-python 5.15.0-89-generic #99-Ubuntu SMP Mon Oct 30 20:42:41 UTC 2023 x86_64
User: arjun (1000)
PHP: 8.1.2-1ubuntu2.20
Disabled: NONE
$ pwd: /home/arjun/projects/env/lib/python3.10/site-packages/__pycache__/
Upload Files
File: //home/arjun/projects/env/lib/python3.10/site-packages/__pycache__/png.cpython-310.pyc
o

we]C�@s`dZdZddlZddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlmZgd�Z
e�dddd	d
ddd
d�	ZdZdd�Ze�dd�Zdd�Zdd�Zdd�Zdd�Zdd�ZGdd�de�ZGdd �d e�ZGd!d"�d"e�ZGd#d$�d$e�ZGd%d&�d&�ZGd'd(�d(�Zd^d*d+�Z d,d-�Z!d.d/�Z"d0d1�Z#d2d3�Z$d4d5�Z%d6d7�Z&ej'd8ej(d9�Z)difd:d;�Z*e*Z+Gd<d=�d=�Z,Gd>d?�d?�Z-d@dA�Z.dBdC�Z/dDdE�Z0dFdG�Z1dHdI�Z2dJdK�Z3dLdM�Z4dNdO�Z5dPdQ�Z6dRdS�Z7dTdU�Z8dVdW�Z9dXdY�Z:dZd[�Z;e<d\k�r.ze;e	j=�WdSe�y-Z>ze?e>e	j@d]�WYdZ>[>dSdZ>[>wwdS)_a
The ``png`` module can read and write PNG files.

Installation and Overview
-------------------------

``pip install pypng``

For help, type ``import png; help(png)`` in your python interpreter.

A good place to start is the :class:`Reader` and :class:`Writer` classes.

Coverage of PNG formats is fairly complete;
all allowable bit depths (1/2/4/8/16/24/32/48/64 bits per pixel) and
colour combinations are supported:

- greyscale (1/2/4/8/16 bit);
- RGB, RGBA, LA (greyscale with alpha) with 8/16 bits per channel;
- colour mapped images (1/2/4/8 bit).

Interlaced images,
which support a progressive display when downloading,
are supported for both reading and writing.

A number of optional chunks can be specified (when writing)
and understood (when reading): ``tRNS``, ``bKGD``, ``gAMA``.

The ``sBIT`` chunk can be used to specify precision for
non-native bit depths.

Requires Python 3.5 or higher.
Installation is trivial,
but see the ``README.txt`` file (with the source distribution) for details.

Full use of all features will need some reading of the PNG specification
http://www.w3.org/TR/2003/REC-PNG-20031110/.

The package also comes with command line utilities.

- ``pripamtopng`` converts
  `Netpbm <http://netpbm.sourceforge.net/>`_ PAM/PNM files to PNG;
- ``pripngtopam`` converts PNG to file PAM/PNM.

There are a few more for simple PNG manipulations.

Spelling and Terminology
------------------------

Generally British English spelling is used in the documentation.
So that's "greyscale" and "colour".
This not only matches the author's native language,
it's also used by the PNG specification.

Colour Models
-------------

The major colour models supported by PNG (and hence by PyPNG) are:

- greyscale;
- greyscale--alpha;
- RGB;
- RGB--alpha.

Also referred to using the abbreviations: L, LA, RGB, RGBA.
Each letter codes a single channel:
*L* is for Luminance or Luma or Lightness (greyscale images);
*A* stands for Alpha, the opacity channel
(used for transparency effects, but higher values are more opaque,
so it makes sense to call it opacity);
*R*, *G*, *B* stand for Red, Green, Blue (colour image).

Lists, arrays, sequences, and so on
-----------------------------------

When getting pixel data out of this module (reading) and
presenting data to this module (writing) there are
a number of ways the data could be represented as a Python value.

The preferred format is a sequence of *rows*,
which each row being a sequence of *values*.
In this format, the values are in pixel order,
with all the values from all the pixels in a row
being concatenated into a single sequence for that row.

Consider an image that is 3 pixels wide by 2 pixels high, and each pixel
has RGB components:

Sequence of rows::

  list([R,G,B, R,G,B, R,G,B],
       [R,G,B, R,G,B, R,G,B])

Each row appears as its own list,
but the pixels are flattened so that three values for one pixel
simply follow the three values for the previous pixel.

This is the preferred because
it provides a good compromise between space and convenience.
PyPNG regards itself as at liberty to replace any sequence type with
any sufficiently compatible other sequence type;
in practice each row is an array (``bytearray`` or ``array.array``).

To allow streaming the outer list is sometimes
an iterator rather than an explicit list.

An alternative format is a single array holding all the values.

Array of values::

  [R,G,B, R,G,B, R,G,B,
   R,G,B, R,G,B, R,G,B]

The entire image is one single giant sequence of colour values.
Generally an array will be used (to save space), not a list.

The top row comes first,
and within each row the pixels are ordered from left-to-right.
Within a pixel the values appear in the order R-G-B-A
(or L-A for greyscale--alpha).

There is another format, which should only be used with caution.
It is mentioned because it is used internally,
is close to what lies inside a PNG file itself,
and has some support from the public API.
This format is called *packed*.
When packed, each row is a sequence of bytes (integers from 0 to 255),
just as it is before PNG scanline filtering is applied.
When the bit depth is 8 this is the same as a sequence of rows;
when the bit depth is less than 8 (1, 2 and 4),
several pixels are packed into each byte;
when the bit depth is 16 each pixel value is decomposed into 2 bytes
(and `packed` is a misnomer).
This format is used by the :meth:`Writer.write_packed` method.
It isn't usually a convenient format,
but may be just right if the source data for
the PNG image comes from something that uses a similar format
(for example, 1-bit BMPs, or another PNG file).
z0.20220715.0�N��array)�Image�Reader�Writer�write_chunks�
from_array�8B��P�N�G�
�
�))rr�r)�rrr)rrrr)�rrr)rrrr)�rrr)rrrrc#s@�tD]\�}�}�|krq��fdd�t|||�D�VqdS)au
    Generate the coordinates for the reduced scanlines
    of an Adam7 interlaced image
    of size `width` by `height` pixels.

    Yields a generator for each pass,
    and each pass generator yields a series of (x, y, xstep) triples,
    each one identifying a reduced scanline consisting of
    pixels starting at (x, y) and taking every xstep pixel to the right.
    c3s�|]}�|�fVqdS�N�)�.0�y��xstart�xstepr�</home/arjun/projects/env/lib/python3.10/site-packages/png.py�	<genexpr>�s�z!adam7_generate.<locals>.<genexpr>N)�adam7�range)�width�height�ystart�ysteprrr�adam7_generate�s� �r$�_Resolutionzx y unit_is_metercCsttt|�g|��Sr)�list�zip�iter)�s�nrrr�group�sr+cCs
t|t�Sr)�
isinstancer)�xrrr�isarray��
r.cCs�|durdSt|�}dt|�krdkstd��td��d}t|�D]B\}}t|�dvr4td|��t|�dkr<d	}|rJt|�d
krJtd|��|D]}t|�|ks_d|kr^dksentd
|��qLq$|S)z�
    Check a palette argument (to the :class:`Writer` class) for validity.
    Returns the palette as a list if okay;
    raises an exception otherwise.
    Nr�zTa palette must have between 1 and 256 entries, see https://www.w3.org/TR/PNG/#11PLTEF)�rz1palette entry %d: entries must be 3- or 4-tuples.r1Trz8palette entry %d: all 4-tuples must precede all 3-tuples�z7palette entry %d: values must be integer: 0 <= x <= 255)r&�len�
ProtocolError�	enumerate�int)�palette�p�seen_triple�i�tr-rrr�
check_palette�sB�����"����r<cCsz|s||fSt|�dkrtd|f��|dur'||dkr'td|d|f��|dur;||dkr;td|d|f��|S)ze
    Check that these arguments, if supplied, are consistent.
    Return a (width, height) pair.
    rz<size argument should be a pair (width, height) instead is %rNrz<size[0] (%r) and width (%r) should match when both are used.rz=size[1] (%r) and height (%r) should match when both are used.)r3r4)�sizer r!rrr�check_sizess&�
��
��r>cCs�|dur|S|r5zt|�Wnty|f}Ynwt|�dkr'td|��t|d�s3td|��|St|�dkrMt|d�rMt|d�rMt|d�sStd|��|S)	z�
    Checks that a colour argument for transparent or background options
    is the right form.
    Returns the colour
    (which, if it's a bare integer, is "corrected" to a 1-tuple).
    Nrz %s for greyscale must be 1-tuplerz'%s colour for greyscale must be integerr1rz&%s colour must be a triple of integers)r3�	TypeErrorr4�
is_natural)�c�	greyscale�whichrrr�check_color&s4
��	�
�
�
��rDc@seZdZdd�ZdS)�ErrorcCs|jjdd�|j�S)Nz: � )�	__class__�__name__�join�args��selfrrr�__str__Esz
Error.__str__N)rH�
__module__�__qualname__rMrrrrrEDsrEc@�eZdZdZdS)�FormatErrorz�
    Problem with input file format.
    In other words, PNG file does not conform to
    the specification in some way and is invalid.
    N�rHrNrO�__doc__rrrrrQI�rQc@rP)r4zh
    Problem with the way the programming interface has been used,
    or the data presented to it.
    NrRrrrrr4QrTr4c@seZdZdS)�
ChunkErrorN)rHrNrOrrrrrUXsrUc@rP)�Defaultz(The default for the greyscale parameter.NrRrrrrrV\rTrVc@sxeZdZdZdddedddddddddddddddfdd�Zdd	�Zd
d�Zdd
�Zdd�Z	dd�Z
dd�Zdd�ZdS)rz%
    PNG encoder in pure Python.
    NFricCsJt|||�\}}~t|�rt|�std��|dks|dkr!td��|dks)|dkr-td��|r7|dur7td��zt|�WntyI|f}Ynw|D]}t|�o]d|ko[d	kn}|sgtd
|f��qLt|�}t|�}t|�}|tur||r|d}t|�}|r�d}d}
nd|}||}
t|�dkr�||
9}t|||||�\}|_	|d
kr�|s�|s�J�|r�J�|d
kr�|r�J�t
||d�}t
|	|d�}	||_||_||_
|	|_|
|_||_||_||_t|�|_||_||_t|�|_||_||_||_t|�|_d|jd|d|j|_|jdv�sJ�||_|
|_|jd
|j|_dS)a(
        Create a PNG encoder object.

        Arguments:

        width, height
          Image size in pixels, as two separate arguments.
        size
          Image size (w,h) in pixels, as single argument.
        greyscale
          Pixels are greyscale, not RGB.
        alpha
          Input data has alpha channel (RGBA or LA).
        bitdepth
          Bit depth: from 1 to 16 (for each channel).
        palette
          Create a palette for a colour mapped image (colour type 3).
        transparent
          Specify a transparent colour (create a ``tRNS`` chunk).
        background
          Specify a default background colour (create a ``bKGD`` chunk).
        gamma
          Specify a gamma value (create a ``gAMA`` chunk).
        compression
          zlib compression level: 0 (none) to 9 (more compressed);
          default: -1 or None.
        interlace
          Create an interlaced image.
        chunk_limit
          Write multiple ``IDAT`` chunks to save memory.
        x_pixels_per_unit
          Number of pixels a unit along the x axis (write a
          `pHYs` chunk).
        y_pixels_per_unit
          Number of pixels a unit along the y axis (write a
          `pHYs` chunk). Along with `x_pixel_unit`, this gives
          the pixel size ratio.
        unit_is_meter
          `True` to indicate that the unit (for the `pHYs`
          chunk) is metre.

        The image size (in pixels) can be specified either by using the
        `width` and `height` arguments, or with the single `size`
        argument.
        If `size` is used it should be a pair (*width*, *height*).

        The `greyscale` argument indicates whether input pixels
        are greyscale (when true), or colour (when false).
        The default is true unless `palette=` is used.

        The `alpha` argument (a boolean) specifies
        whether input pixels have an alpha channel (or not).

        `bitdepth` specifies the bit depth of the source pixel values.
        Each channel may have a different bit depth.
        Each source pixel must have values that are
        an integer between 0 and ``2**bitdepth-1``, where
        `bitdepth` is the bit depth for the corresponding channel.
        For example, 8-bit images have values between 0 and 255.
        PNG only stores images with bit depths of
        1,2,4,8, or 16 (the same for all channels).
        When `bitdepth` is not one of these values or where
        channels have different bit depths,
        the next highest valid bit depth is selected,
        and an ``sBIT`` (significant bits) chunk is generated
        that specifies the original precision of the source image.
        In this case the supplied pixel values will be rescaled to
        fit the range of the selected bit depth.

        The PNG file format supports many bit depth / colour model
        combinations, but not all.
        The details are somewhat arcane
        (refer to the PNG specification for full details).
        Briefly:
        Bit depths < 8 (1,2,4) are only allowed with greyscale and
        colour mapped images;
        colour mapped images cannot have bit depth 16.

        For colour mapped images
        (in other words, when the `palette` argument is specified)
        the `bitdepth` argument must match one of
        the valid PNG bit depths: 1, 2, 4, or 8.
        (It is valid to have a PNG image with a palette and
        an ``sBIT`` chunk, but the meaning is slightly different;
        it would be awkward to use the `bitdepth` argument for this.)

        The `palette` option, when specified,
        causes a colour mapped image to be created:
        the PNG colour type is set to 3;
        `greyscale` must not be true; `alpha` must not be true;
        `transparent` must not be set.
        The bit depth must be 1,2,4, or 8.
        When a colour mapped image is created,
        the pixel values are palette indexes and
        the `bitdepth` argument specifies the size of these indexes
        (not the size of the colour values in the palette).

        The palette argument value should be a sequence of 3- or
        4-tuples.
        3-tuples specify RGB palette entries;
        4-tuples specify RGBA palette entries.
        All the 4-tuples (if present) must come before all the 3-tuples.
        A ``PLTE`` chunk is created;
        if there are 4-tuples then a ``tRNS`` chunk is created as well.
        The ``PLTE`` chunk will contain all the RGB triples in the same
        sequence;
        the ``tRNS`` chunk will contain the alpha channel for
        all the 4-tuples, in the same sequence.
        Palette entries are always 8-bit.

        If specified, the `transparent` and `background` parameters must be
        a tuple with one element for each channel in the image.
        Either a 3-tuple of integer (RGB) values for a colour image, or
        a 1-tuple of a single integer for a greyscale image.

        If specified, the `gamma` parameter must be a positive number
        (generally, a `float`).
        A ``gAMA`` chunk will be created.
        Note that this will not change the values of the pixels as
        they appear in the PNG file,
        they are assumed to have already
        been converted appropriately for the gamma specified.

        The `compression` argument specifies the compression level to
        be used by the ``zlib`` module.
        Values from 1 to 9 (highest) specify compression.
        0 means no compression.
        -1 and ``None`` both mean that the ``zlib`` module uses
        the default level of compression (which is generally acceptable).

        If `interlace` is true then an interlaced image is created
        (using PNG's so far only interlace method, *Adam7*).
        This does not affect how the pixels should be passed in,
        rather it changes how they are arranged into the PNG file.
        On slow connexions interlaced images can be
        partially decoded by the browser to give
        a rough view of the image that is
        successively refined as more image data appears.

        .. note ::

          Enabling the `interlace` option requires the entire image
          to be processed in working memory.

        `chunk_limit` is used to limit the amount of memory used whilst
        compressing the image.
        In order to avoid using large amounts of memory,
        multiple ``IDAT`` chunks may be created.
        z!width and height must be integersrz*width and height must be greater than zero��z&width and height cannot exceed 2**31-1Nz1transparent colour not allowed with alpha channelr�z1each bitdepth %r must be a positive integer <= 16F�r1rr�transparent�
backgroundrr�rrr1r�) r>r@r4r3r?r<�boolrV�check_bitdepth_rescale�rescalerDr r!rZr[�gammarB�alpha�colormapr6�bitdepth�compression�chunk_limit�	interlacer7�x_pixels_per_unit�y_pixels_per_unit�
unit_is_meter�
color_type�color_planes�planes�psize)rLr r!r=rBrbrdr7rZr[rarergrmrc�maxvalrfrhrirj�b�validrlrrr�__init__es�/�
� ���
�


��zWriter.__init__cs||j|j��fdd�}|jr&d|jdk}t|tj||���}|�||�S|�|||��}||j	kr<t
d||j	f��|S)as
        Write a PNG image to the output file.
        `rows` should be an iterable that yields each row
        (each row is a sequence of values).
        The rows should be the rows of the original image,
        so there should be ``self.height`` rows of
        ``self.width * self.planes`` values.
        If `interlace` is specified (when creating the instance),
        then an interlaced PNG file will be written.
        Supply the rows in the normal image order;
        the interlacing is carried out internally.

        .. note ::

          Interlacing requires the entire image to be in working memory.
        c	3s`�t|�D](\}}zt|��k}Wntyd}Ynw|r*td�t|�|f��|VqdS)zk
            Yield each row in rows,
            but check each row first (for correct width).
            Fz/Expected %d values but got %d values, in row %dN)r5r3r?r4)�rowsr:�row�wrong_length��vprrr�
check_rows�s�����z Writer.write.<locals>.check_rows�BHrz-rows supplied (%d) does not match height (%d))r rmrgrdr�	itertools�chain�write_array�write_passesr!r4)rL�outfilersrx�fmt�a�nrowsrrvr�writens
��zWriter.writecCsH|jr	t||j�}|jdkrt||j�}n	|jdkrt|�}|�||�S)a;
        Write a PNG image to the output file.

        Most users are expected to find the :meth:`write` or
        :meth:`write_array` method more convenient.

        The rows should be given to this method in the order that
        they appear in the output file.
        For straightlaced images, this is the usual top to bottom ordering.
        For interlaced images the rows should have been interlaced before
        passing them to this function.

        `rows` should be an iterable that yields each row
        (each row being a sequence of values).
        rrX)r`�rescale_rowsrd�	pack_rows�unpack_rows�write_packed)rLr~rsrrrr}�s

zWriter.write_passesc	Cs�|�|�|jdurt�|j�}nt��}t�}d}t|�D]'\}}|�d�|�|�t|�|j	krE|�
|�}t|�rBt|d|�t�}q|�
t|��}|�
�}t|�sYt|�rat|d||�t|d�|dS)a�
        Write PNG file to `outfile`.
        `rows` should be an iterator that yields each packed row;
        a packed row being a sequence of packed bytes.

        The rows have a filter byte prefixed and
        are then compressed into one or more IDAT chunks.
        They are not processed any further,
        so if bitdepth is other than 1, 2, 4, 8, 16,
        the pixel values should have been scaled
        before passing them to this method.

        This method does work for interlaced images but it is best avoided.
        For interlaced images, the rows should be
        presented in the order that they appear in the file.
        N���r�IDAT�IENDr)�write_preamblere�zlib�compressobj�	bytearrayr5�append�extendr3rf�compress�write_chunk�bytes�flush)	rLr~rs�
compressor�datar:rt�
compressed�flushedrrrr��s*




�
zWriter.write_packedc
Cs�z|�t�Wnty}ztd�|�d}~wwt|dt�d|j|j|j	|j
dd|j��|jdurDt|dt�dt
t|jd����|jr]t|dtjd	|jgd
d�|jD��R��|jrut|j�\}}t|d|�|rut|d
|�|jdur�|jr�d}nd}t|d
tj|g|j�R��|jdur�|jr�d}nd}t|dtj|g|j�R��|jdur�|jdur�|j|jt
|j�f}t|dtjdg|�R��dSdSdS)Nz&PNG must be written to a binary streamsIHDR�!2I5BrsgAMA�!L�j�@ssBIT�%dBcSsg|]}|d�qS)rr�rr)rrr�
<listcomp>�z)Writer.write_preamble.<locals>.<listcomp>sPLTEstRNSz!1Hz!3HsbKGDspHYs�!LLB)r��	signaturer?r4r��struct�packr r!rdrkrgrar6�roundr`rmr7�make_palette_chunksrZrBr[rhrirj)rLr~�er8r;r�tuprrrr��sf
����
���

�
�

��zWriter.write_preamblecCsN|jrt|�tkrd|jdk}t||�}|�||�|��S|�||�|��S)z�
        Write an array that holds all the image values
        as a PNG file on the output file.
        See also :meth:`write` method.
        ryr)rg�typerrdr}�array_scanlines_interlace�array_scanlines)rLr~�pixelsrrrrr|Bs
��zWriter.write_arrayccs@�|j|j}d}t|j�D]}|}||}|||�VqdS)zc
        Generates rows (each a sequence of values) from
        a single array of values.
        rN)r rmrr!)rLr�rw�stopr�startrrrr�Xs��zWriter.array_scanlinesccs�d|jdk}|j|j}t|j|j�D]j}|D]e\}}}tt�|j|t|���}||j}	|dkrC||}
||
|
|�Vqt	|�}|�
|d|	��||||j}
|d|}|j|}
t|j�D]}||
|||
�||d|j�<qi|VqqdS)a
        Generator for interlaced scanlines from an array.
        `pixels` is the full source image as a single array of values.
        The generator yields each scanline of the reduced passes in turn,
        each scanline being a sequence of values.
        ryrrrN)rdr rmr$r!r6�math�ceil�floatrr�r)rLr�rrw�linesr-rr�ppr�reduced_row_len�offsetrt�
end_offset�skipr:rrrr�fs,�


���z Writer.array_scanlines_interlace)
rHrNrOrSrVrrr�r}r�r�r|r�r�rrrrr`s<
�59Hr�cCsft|�}|�t�dt|���|�|�|�|�t�|�}t�||�}|dM}|�t�d|��dS)zR
    Write a PNG chunk to the output file, including length and
    checksum.
    �!Il��N)r�r�r�r�r3r��crc32)r~�tagr��checksumrrrr��s


r�cCs(|�t�|D]
}t|g|�R�qdS)z,Create a PNG file by writing out the chunks.N)r�r�r�)�out�chunks�chunkrrrr�s
�rc		#s��dd�|D��tdd�|D��}t|�dksJ�|\}d|dk}t|�}|D],}t|t|��}t|�D]�t|��fdd�|�d	|�D��}||�d	|�<q5|Vq(d	S)
a
    Take each row in rows (an iterator) and yield
    a fresh row with the pixels scaled according to
    the rescale parameters in the list `rescale`.
    Each element of `rescale` is a tuple of
    (source_bitdepth, target_bitdepth),
    with one element per channel.
    cSs4g|]}td|dd�td|dd��qS)rrr�r�r�rrrr��s,�z rescale_rows.<locals>.<listcomp>css�|]}|dVqdS)rNrr�rrrr���zrescale_rows.<locals>.<genexpr>rryrc3s$�|]
}tt��|��VqdSr�r6r��rr-��fsr:rrr�s�"N)�setr3rr(r)	rsr`�target_bitdepths�target_bitdepth�typecode�n_chansrt�rescaled_row�channelrr�rr��s&����r�c#s���dksJ�d�dksJ�td��}�fdd��|D]2}t|�}tt|��}t�||�||}|�dgt|��t||�}t�fdd�|D��VqdS)zjYield packed rows that are a byte array.
    Each byte is packed with the values from several pixels.
    rrcsd}|D]}|�>|}q|S)zWTake a block of (2, 4, or 8) values,
        and pack them into a single byte.
        rr)�block�res�v�rdrr�	make_byte�szpack_rows.<locals>.make_bytec3s�|]}�|�VqdSrr)rr�)r�rrr�r�zpack_rows.<locals>.<genexpr>N)r6r�r�r3r�r�r�r+)rsrd�spbrtr�r*�extra�blocksr)rdr�rr��s�

�r�ccs4�|D]}dt|�}ttj|g|�R��VqdS)zTUnpack each row from being 16-bits per value,
    to being a sequence of bytes.
    �!%dHN)r3r�r�r�)rsrtrrrrr��s
��r�cCsVt�}t�}|D]}|�|dd��t|�dkr |�|d�q|r'||fS|dfS)z�
    Create the byte sequences for a ``PLTE`` and
    if necessary a ``tRNS`` chunk.
    Returned as a pair (*p*, *t*).
    *t* will be ``None`` if no ``tRNS`` chunk is necessary.
    rr1N)r�r�r3r�)r7r8r;r-rrrr��s�r�cs
|r/t|�dkrtd��|\}|dvrtd��|durtd��|r%td��|r+td��|dfS|r[|s[|\}|d	vr>|dfS|d
krEd�n|dkrLd
�n|dvsRJ�d
��|�fgfS|sa|raJ�tt|��}|dvrr|\}|dfSdt|�d
k���fdd�|D�fS)z+
    Returns (bitdepth, rescale) pair.
    rz0with palette, only a single bitdepth may be used)rrrrz,with palette, bitdepth must be 1, 2, 4, or 8Nz&transparent and palette not compatiblez alpha and palette not compatiblez$greyscale and palette not compatible�rrrrrXrrXr1r)�r]�))r)rX)rrXcsg|]}|�f�qSrr)rrp��targetbitdepthrrr�8r�z*check_bitdepth_rescale.<locals>.<listcomp>)r3r4�tupler��max)r7rdrZrbrB�	depth_setrr�rr_	sF��r_z(LA?|RGBA?);?([0-9]*))�flagscCs&t|�}t�|�}|std��|��\}}|rt|�}d|vr-t|d�d|vkr-td��d|v|d<d|v}d|vrGt|d�|krGtd��||d<|rf|�d�rb||dkrbtd	||df��||d<t	|�d
�|�d�|�d��\}}|r}||d<|r�||d<d|vr�zt
|�|d<Wnty�td
��wt
|�}d|vr�|d|kr�td��t�
|�\}}	t|	�}
~	|
}d|vr�t
|
�|}||d<d|v�rz|j}Wnty�zd|j}Wnty�d}YnwYnw|jdkr�d}nd|j}||d<dD]
}
|
|v�sJ��qt||�S)a8

    Create a PNG :class:`Image` object from a 2-dimensional array.
    One application of this function is easy PIL-style saving:
    ``png.from_array(pixels, 'L').save('foo.png')``.

    Unless they are specified using the *info* parameter,
    the PNG's height and width are taken from the array size.
    The first axis is the height; the second axis is the
    ravelled width and channel index.
    The array is treated is a sequence of rows,
    each row being a sequence of values (``width*channels`` in number).
    So an RGB image that is 16 pixels high and 8 wide will
    occupy a 2-dimensional array that is 16x24
    (each row will be 8*3 = 24 sample values).

    *mode* is a string that specifies the image colour format in a
    PIL-style mode.  It can be:

    ``'L'``
      greyscale (1 channel)
    ``'LA'``
      greyscale with alpha (2 channel)
    ``'RGB'``
      colour image (3 channel)
    ``'RGBA'``
      colour image with alpha (4 channel)

    The mode string can also specify the bit depth
    (overriding how this function normally derives the bit depth,
    see below).
    Appending ``';16'`` to the mode will cause the PNG to be
    16 bits per channel;
    any decimal from 1 to 16 can be used to specify the bit depth.

    When a 2-dimensional array is used *mode* determines how many
    channels the image has, and so allows the width to be derived from
    the second array dimension.

    The array is expected to be a ``numpy`` array,
    but it can be any suitable Python sequence.
    For example, a list of lists can be used:
    ``png.from_array([[0, 255, 0], [255, 0, 255]], 'L')``.
    The exact rules are: ``len(a)`` gives the first dimension, height;
    ``len(a[0])`` gives the second dimension.
    It's slightly more complicated than that because
    an iterator of rows can be used, and it all still works.
    Using an iterator allows data to be streamed efficiently.

    The bit depth of the PNG is normally taken from
    the array element's datatype
    (but if *mode* specifies a bitdepth then that is used instead).
    The array element's datatype is determined in a way which
    is supposed to work both for ``numpy`` arrays and for Python
    ``array.array`` objects.
    A 1 byte datatype will give a bit depth of 8,
    a 2 byte datatype will give a bit depth of 16.
    If the datatype does not have an implicit size,
    like the above example where it is a plain Python list of lists,
    then a default of 8 is used.

    The *info* parameter is a dictionary that can
    be used to specify metadata (in the same style as
    the arguments to the :class:`png.Writer` class).
    For this function the keys that are useful are:

    height
      overrides the height derived from the array dimensions and
      allows *a* to be an iterable.
    width
      overrides the width derived from the array dimensions.
    bitdepth
      overrides the bit depth derived from the element datatype
      (but must match *mode* if that also specifies a bit depth).

    Generally anything specified in the *info* dictionary will
    override any implicit choices that this function would otherwise make,
    but must match any explicit ones.
    For example, if the *info* dictionary has a ``greyscale`` key then
    this must be true when mode is ``'L'`` or ``'LA'`` and
    false when mode is ``'RGB'`` or ``'RGBA'``.
    z1mode string should be 'RGB' or 'L;16' or similar.rB�Lz$info['greyscale'] should match mode.�Arbz info['alpha'] should match mode.rdz1bitdepth (%d) should match bitdepth of info (%d).r=r r!z4len(a) does not work, supply info['height'] instead.rmz!info['planes'] should match mode.rrpr)r r!rdrBrb)�dict�RegexModeDecode�matchrE�groupsr6r^r4�getr>r3r?rz�tee�next�dtype�AttributeError�itemsize�kindr)r��mode�infor�rdrbr r!rmr;rt�testelementr��thingrrrr?s�U

�����

���


rc@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)rz�A PNG image.  You can create an :class:`Image` object from
    an array of pixels by calling :meth:`png.from_array`.  It can be
    saved to disk with the :meth:`save` method.
    cCs||_||_dS)z^
        .. note ::

          The constructor is not public.  Please do not call it.
        N)rsr�)rLrsr�rrrrr�s
zImage.__init__cCsNtdi|j��}t|d��}|�||j�Wd�dS1s wYdS)aGSave the image to the named *file*.

        See `.write()` if you already have an open file object.

        In general, you can only call this method once;
        after it has been called the first time the PNG image is written,
        the source data will have been streamed, and
        cannot be streamed again.
        �wbNr)rr��openr�rs)rL�file�w�fdrrr�saves"�z
Image.savecCst|j�|_dS)zrStream the rows into a list, so that the rows object
        can be accessed multiple times, or randomly.
        N)r&rsrKrrr�streamszImage.streamcCs"tdi|j��}|�||j�dS)a:Write the image to the open file object.

        See `.save()` if you have a filename.

        In general, you can only call this method once;
        after it has been called the first time the PNG image is written,
        the source data will have been streamed, and
        cannot be streamed again.
        Nr)rr�r�rs)rLr�r�rrrr�szImage.writeN)rHrNrOrSrrr�r�r�rrrrr�s
rc@s�eZdZdZd=dd�Zd>dd�Zdd	�Zd
d�Zdd
�Zdd�Z	d?dd�Z
dd�Zdd�Zd>dd�Z
dd�Zd>dd�Zdd�Zdd�Zd d!�Zd"d#�Zd$d%�Zd&d'�Zd(d)�Zd>d*d+�Zd,d-�Zd@d/d0�Zd1d2�Zd3d4�Zd5d6�Zd7d8�Zd9d:�Zd;d<�ZdS)Arz1
    Pure Python PNG decoder in pure Python.
    NcCs�|du|du|du|du}|dkrtd��d|_d|_d|_|dur;t|�r,|}nt|t�r4|}nt|d�r;|}|durGt�	|�|_
dS|durSt|d�|_
dS|dur\||_
dStd��)a�
        The constructor expects exactly one keyword argument.
        If you supply a positional argument instead,
        it will guess the input type.
        Choose from the following keyword arguments:

        filename
          Name of input file (a PNG file).
        file
          A file-like object (object with a read() method).
        bytes
          ``bytes`` or ``bytearray`` with PNG data.

        Nrz!Reader() takes exactly 1 argument�read�rbz'expecting filename, file or bytes array)
r?r�rZ�atchunkr.r,�str�hasattr�io�BytesIOr�r�r4)rL�_guess�filenamer�r��keywords_suppliedrrrrr0s6����


zReader.__init__Fc
Cs|��|js|��|_|jstd��|j\}}d|_|j�|�}t|�|kr/td||f��|j�d�}t|�dkrAtd|��t�|�}t�||�}t	�
d|�}||kr~t	�d|�\}t	�d|�\}d|�d�||f}	|rzt
�|	t�||fSt|	��||fS)	a�
        Read the next PNG chunk from the input file;
        returns a (*type*, *data*) tuple.
        *type* is the chunk's type as a byte string
        (all PNG chunk types are 4 bytes long).
        *data* is the chunk's data content, as a byte string.

        If the optional `lenient` argument evaluates to `True`,
        checksum failures will raise warnings rather than exceptions.
        zNo more chunks.Nz*Chunk %s too short for required %i octets.rz Chunk %s too short for checksum.r�z-Checksum error in %s chunk: 0x%08X != 0x%08X.�ascii)�validate_signaturer��_chunk_len_typerUr�r�r3r�r�r�r��unpack�decode�warnings�warn�RuntimeWarning)
rL�lenient�lengthr�r�r��verifyr�rp�messagerrrr�as>

��
��zReader.chunkccs(�	|��\}}||fV|dkrdSq)zbReturn an iterator that will yield each chunk as a
        (*chunktype*, *content*) pair.
        Tr�N)r�)rLr;r�rrrr��s�
�z
Reader.chunkscCsf|}|dkr|S|dvrtd��td|j�}|s!tdgt|��}dttttf|}|||||�|S)a
        Undo the filter for a scanline.
        `scanline` is a sequence of bytes that
        does not include the initial filter type byte.
        `previous` is decoded previous scanline
        (for straightlaced images this is the previous pixel row,
        but for interlaced images, it is
        the previous scanline in the reduced image,
        which in general is not the previous pixel row in the final image).
        When there is no previous scanline
        (the first row of a straightlaced image,
        or the first row in one of the passes in an interlaced image),
        then this argument should be ``None``.

        The scanline will have the effects of filtering removed;
        the result will be returned as a fresh sequence of bytes.
        r)rrr1rzTInvalid PNG Filter Type.  See http://www.w3.org/TR/2003/REC-PNG-20031110/#9Filters .rN)	rQr�rnr�r3�undo_filter_sub�undo_filter_up�undo_filter_average�undo_filter_paeth)rL�filter_type�scanline�previous�result�fu�fnrrr�undo_filter�s(���zReader.undo_filtercCsh|j|j}||j}|jdkrtddg|�}ntdg|�}d}t|j|j�D]�}d}|D]�\}}	}
tt�	|j|t
|
���}tt�	|j|��}||}
|d7}||||�}||7}|�|
||�}|j
||d�}|
dkr�|dksxJ�|	|}|||||�<q/|	|||j}|	d|}|j|
}t|j�D]}||d|j�|||||�<q�q/q)|S)zw
        Read raw pixel data, undo filters, deinterlace, and flatten.
        Return a single array of values.
        r�HrNr)r )r rmr!rdrr�r$r6r�r�r�rnr�_bytes_to_valuesr)rL�rawrw�vpir��
source_offsetr��reconr-rrr��row_sizerr�flatr�r�r�r:rrr�_deinterlace�s<


���zReader._deinterlaceccs�|D]}|�|�VqdS)z�
        Iterator that yields each scanline;
        each scanline being a sequence of values.
        `byte_rows` should be an iterator that yields
        the bytes of each row in turn.
        N)r)rL�	byte_rowsrtrrr�_iter_bytes_to_valuess��zReader._iter_bytes_to_valuescs��jdkr	t|�S�jdkrtdt�dt|�d|��S�jdks$J�|dur+�j}d�j}t�}d�jd��fdd	�ttt	|���D�}|D]�|�
��fd
d	�|D��qK|d|�S)z�Convert a packed row of bytes into a row of values.
        Result will be a freshly allocated object,
        not shared with the argument.
        rrXrr�rNrcsg|]}�j|�qSrr��rr:rKrrr�s�z+Reader._bytes_to_values.<locals>.<listcomp>csg|]}��|?@�qSrrr!)�mask�orrr�"s)rdr�rr�rr3r �reversedr&rr�)rL�bsr r�r��shiftsr)r"r#rLrrs$

�

�zReader._bytes_to_valuesccs��|j}t�}d}|D]4}|�|�t|�|dkr?|d}|d|d�}|d|d�=|�|||�}|Vt|�|dksqt|�dkrJtd��t|�dksRJ�dS)aIterator that undoes the effect of filtering;
        yields each row as a sequence of packed bytes.
        Assumes input is straightlaced.
        `byte_blocks` should be an iterable that yields the raw bytes
        in blocks of arbitrary size.
        Nrrz'Wrong size for decompressed IDAT chunk.)�	row_bytesr�r�r3rrQ)rL�byte_blocksr�r�r�
some_bytesrrrrr�_iter_straight_packed%s"�	
��zReader._iter_straight_packedcCsD|jrdS|j�d�|_t|j�dkrtd��|jtkr td��dS)a�
        If signature (header) has not been read then read and
        validate it; otherwise do nothing.
        No signature (empty read()) will raise EOFError;
        An invalid signature will raise FormatError.
        EOFError is raised to make possible the case where
        a program can read multiple PNG files from the same stream.
        The end of the stream can be distinguished from non-PNG files
        or corrupted PNG files.
        NrrzEnd of PNG stream.zPNG file has invalid signature.)r�r�r�r3�EOFErrorrQrKrrrrBs
�zReader.validate_signaturecCsL|��	|js|��|_|jdurtd��|jddkrdS|j|d�q)a�
        Extract the image metadata by reading
        the initial part of the PNG file up to
        the start of the ``IDAT`` chunk.
        All the chunks that precede the ``IDAT`` chunk are
        read and either processed for metadata or discarded.

        If the optional `lenient` argument evaluates to `True`,
        checksum failures will raise warnings rather than exceptions.
        TNz!This PNG file has no IDAT chunks.rr��r)rr�rrQ�
process_chunk)rLrrrr�preambleVs

�zReader.preamblecCs�|j�d�}|s
dSt|�dkrtd��t�d|�\}}|dkr(td||f��tt|��}|ttdd��ttd	d
��BksFtdt	|���||fS)z�
        Reads just enough of the input to
        determine the next chunk's length and type;
        return a (*length*, *type*) pair where *type* is a byte sequence.
        If there are no more chunks, ``None`` is returned.
        rNz1End of file whilst reading chunk length and type.z!I4srWzChunk %s is too large: %d.�A�[�a�{z Chunk %r has invalid Chunk Type.)
r�r�r3rQr�rr�r�rr&)rLr-rr��
type_bytesrrrrms$� ��zReader._chunk_len_typecCs>|j|d�\}}d|�d�}t||d�}|r||�dSdS)am
        Process the next chunk and its data.
        This only processes the following chunk types:
        ``IHDR``, ``PLTE``, ``bKGD``, ``tRNS``, ``gAMA``, ``sBIT``, ``pHYs``.
        All other chunk types are ignored.

        If the optional `lenient` argument evaluates to `True`,
        checksum failures will raise warnings rather than exceptions.
        r,�	_process_r�N)r�r�getattr)rLrr�r��method�mrrrr-�s�zReader.process_chunkcCsNt|�dkr
td��t�d|�\|_|_|_|_|_|_	|_
t|j|j�|jdkr1td|j��|j	dkr=td|j	��|j
dvrItd|j
��t|jd	@�}|jd
@}t|jd@�}d|pa|}||}||_
||_||_||_||_t|j�td
�||_t|j�|jkr�t|j�|_tt�|j|j��|_d|_d|_d|_dS)Nrz IHDR chunk has incorrect length.r�rzUnknown compression method %dzTUnknown filter method %d, see http://www.w3.org/TR/2003/REC-PNG-20031110/#9Filters .)rrz`Unknown interlace method %d, see http://www.w3.org/TR/2003/REC-PNG-20031110/#8InterlaceMethods .rrrrYr)r3rQr�rr r!rdrkre�filterrg�check_bitdepth_colortyper^rcrBrbrlrmr�rnr6r�r�r'�plte�trns�sbit)rLr�rcrBrbrlrmrrr�
_process_IHDR�sP
�
�
��
��
zReader._process_IHDRcCsd|jrt�d�||_t|�ddkrtd��t|�d|jdkr&td��t|�dkr0td��dS)NzMultiple PLTE chunks present.r1rz.PLTE chunk's length should be a multiple of 3.rzPLTE chunk is too long.zEmpty PLTE is not allowed.)r:rrr3rQrd�rLr�rrr�
_process_PLTE�s
��zReader._process_PLTEcCs^z"|jr|jst�d�t�d|�|_WdSt�d|j|�|_WdStjy.t	d��w)Nz)PLTE chunk is required before bKGD chunk.�Br�z bKGD chunk has incorrect length.)
rcr:rrr�rr[rl�errorrQr>rrr�
_process_bKGD�s���zReader._process_bKGDcCs�||_|jr!|jst�d�dSt|�t|j�dkrtd��dS|jr+td|j��z
t	�
d|j|�|_WdSt	j
yDtd��w)Nz)PLTE chunk is required before tRNS chunk.r1ztRNS chunk is too long.z,tRNS chunk is not valid with colour type %d.r�z tRNS chunk has incorrect length.)r;rcr:rrr3rQrbrkr�rrlrZrAr>rrr�
_process_tRNS�s&���
��zReader._process_tRNScCs6zt�d|�dd|_WdStjytd��w)Nr�rr�z gAMA chunk has incorrect length.)r�rrarArQr>rrr�
_process_gAMA�s
�zReader._process_gAMAcCs<||_|jrt|�dks|jst|�|jkrtd��dSdS)Nr1z sBIT chunk has incorrect length.)r<rcr3rmrQr>rrr�
_process_sBITs��zReader._process_sBITcCsH||_d}t|�t�|�krtd��t�||�\|_|_}t|�|_	dS)Nr�z pHYs chunk has incorrect length.)
�physr3r��calcsizerQrrhrir^rj)rLr�r�unitrrr�
_process_pHYss
�zReader._process_pHYscs���fdd�}�j�d�t|����jr ��fdd�}|�}n�������}t�}d��D]	}t�|�||<q/�j�j	f|d<d��D]}t�|d	�}|d	urU|||<qEt�d
d	�rgt
�j�j�j
�|d<�jrp���|d<�j�j	||fS)
a`
        Read the PNG file and decode it.
        Returns (`width`, `height`, `rows`, `info`).

        May use excessive memory.

        `rows` is a sequence of rows;
        each row is a sequence of values.

        If the optional `lenient` argument evaluates to True,
        checksum failures will raise warnings rather than exceptions.
        c3sH�	�j�d�\}}|dkrdS|dkrq�jr �js t�d�|Vq)z8Iterator that yields all the ``IDAT`` chunks as strings.Tr,r�r�z(PLTE chunk is required before IDAT chunkN)r�rcr:rr)r�r�)rrLrr�iteridats�
�zReader.read.<locals>.iteridatr,c3sj�ttj���}d�jdk}��|�}�j�j}tdt|�|�D]}t	|||||��}|Vq"dS)z&Yield each row from an interlaced PNG.ryrrN)
r�rzr{rdrr rmrr3r)r%�	arraycode�valuesrwr:rt)rrLrr�rows_from_interlace2s�
�z(Reader.read.<locals>.rows_from_interlacez)greyscale alpha planes bitdepth interlacer=zgamma transparent backgroundNrh�physicalr7)r.�
decompressrgr r*r��splitr5r r!�
Resolutionrhrirjr:r7)rLrrJrMrsr��attrr�r)rrrLrr�s0

��zReader.readcCs<|��\}}}}d|ddk}t|tj|��}||||fS)a@
        Read a PNG file and decode it into a single array of values.
        Returns (*width*, *height*, *values*, *info*).

        May use excessive memory.

        `values` is a single array.

        The :meth:`read` method is more stream-friendly than this,
        because it returns a sequence of rows.
        ryrdr)r�rrzr{)rLr-r�pixelr�rKrrr�	read_flatRs
zReader.read_flat�naturalcCsv|jstd��ttd|j�d�}|js|dkr9td|jpg�}|�dgt|�t|��ttt	j
|t|d���}|S)a�
        Returns a palette that is a sequence of 3-tuples or 4-tuples,
        synthesizing it from the ``PLTE`` and ``tRNS`` chunks.
        These chunks should have already been processed (for example,
        by calling the :meth:`preamble` method).
        All the tuples are the same size:
        3-tuples if there is no ``tRNS`` chunk,
        4-tuples when there is a ``tRNS`` chunk.

        Assumes that the image is colour type
        3 and therefore a ``PLTE`` chunk is required.

        If the `alpha` argument is ``'force'`` then an alpha channel is
        always added, forcing the result to be a sequence of 4-tuples.
        z6Required PLTE chunk is missing in colour type 3 image.r@r1�forcer2r)r:rQr+rr;r�r3r&�map�operator�add)rLrbr:r;rrrr7ds�zReader.palettec
s�|��|js|js|js|��S|��\}}}}|jrCd|d<t|j�|d<d|d<dt|j�|d<|����fdd	�}||�}n3|jrv|j�d
|dd�|d�d|d<|dd7<d
|ddk�����fdd�}||�}d}|jr�t�	dt
|j�|j�}t|�}||dkr�td||j
f��t|�dkr�td|��|r�|d|�||d<�fdd�}	|	|�}||||fS)ak
        Returns the image data as a direct representation of
        an ``x * y * planes`` array.
        This removes the need for callers to deal with
        palettes and transparency themselves.
        Images with a palette (colour type 3) are converted to RGB or RGBA;
        images with transparency (a ``tRNS`` chunk) are converted to
        LA or RGBA as appropriate.
        When returned in this format the pixel values represent
        the colour value directly without needing to refer
        to palettes or transparency information.

        Like the :meth:`read` method this method returns a 4-tuple:

        (*width*, *height*, *rows*, *info*)

        This method normally returns pixel values with
        the bit depth they have in the source image, but
        when the source PNG has an ``sBIT`` chunk it is inspected and
        can reduce the bit depth of the result pixels;
        pixel values will be reduced according to the bit depth
        specified in the ``sBIT`` chunk.
        PNG nerds should note a single result bit depth is
        used for all channels:
        the maximum of the ones specified in the ``sBIT`` chunk.
        An RGB565 image will be rescaled to 6-bit RGB666.

        The *info* dictionary that is returned reflects
        the `direct` format and not the original source image.
        For example, an RGB source image with a ``tRNS`` chunk
        to represent a transparent colour,
        will start with ``planes=3`` and ``alpha=False`` for the
        source image,
        but the *info* dictionary returned by this method
        will have ``planes=4`` and ``alpha=True`` because
        an alpha channel is synthesized and added.

        *rows* is a sequence of rows;
        each row being a sequence of values
        (like the :meth:`read` method).

        All the other aspects of the image data are not changed.
        Frcrbrrdr1rmc3s4�|D]}�fdd�|D�}tdtj|��VqdS)Ncsg|]}�|�qSrrr��r:rrr��r�z4Reader.asDirect.<locals>.iterpal.<locals>.<listcomp>r@)rrzr{�r�rtrZrr�iterpal�s
��z Reader.asDirect.<locals>.iterpalrrTryc3sZ�|D]'}t|��}t�j|�}t�j|�}tt|��}t�tjtt	j
||���VqdSr)r+rW�__ne__�__mul__r&r'rrzr{rXrY)r�rt�opa)�itrormr�rr�itertrns�s�
��z!Reader.asDirect.<locals>.itertrnsNr�z!sBIT chunk %r exceeds bitdepth %drzsBIT chunk %r has a 0-entryc3s$�|D]}�fdd�|D�VqdS)Ncsg|]}|�?�qSrr)rr8��shiftrrr��r�z6Reader.asDirect.<locals>.itershift.<locals>.<listcomp>rr[rbrr�	itershift����z"Reader.asDirect.<locals>.itershift)r.rcr;r<r�r^r7rZr�rr3r�rErd�min)
rLr-rr�r�r\rar�r<rdr)r`rormr:rcr�r�asDirectsJ-
�zReader.asDirectc	sr|�\}}�}d|dd}d|d}t|�t|��||d<��fdd�}||kr2||�|fS|||�|fS)z2Helper used by :meth:`asRGB8` and :meth:`asRGBA8`.rrdrc3s$��D]}�fdd�|D�VqdS)Ncsg|]
}tt|����qSrr�r�)�factorrrr��sz9Reader._as_rescale.<locals>.iterscale.<locals>.<listcomp>r)rt�rhr�rr�	iterscale�rez%Reader._as_rescale.<locals>.iterscaler�)	rLr�r�r r!r�ro�targetmaxvalrjrrir�_as_rescale�szReader._as_rescalecC�|�|jd�S)a5
        Return the image data as an RGB pixels with 8-bits per sample.
        This is like the :meth:`asRGB` method except that
        this method additionally rescales the values so that
        they are all between 0 and 255 (8-bit).
        In the case where the source image has a bit depth < 8
        the transformation preserves all the information;
        where the source image has bit depth > 8, then
        rescaling to 8-bit values loses precision.
        No dithering is performed.
        Like :meth:`asRGB`,
        an alpha channel in the source image will raise an exception.

        This function returns a 4-tuple:
        (*width*, *height*, *rows*, *info*).
        *width*, *height*, *info* are as per the :meth:`read` method.

        *rows* is the pixel data as a sequence of rows.
        r)rl�asRGBrKrrr�asRGB8sz
Reader.asRGB8cCrm)aY
        Return the image data as RGBA pixels with 8-bits per sample.
        This method is similar to :meth:`asRGB8` and :meth:`asRGBA`:
        The result pixels have an alpha channel, *and*
        values are rescaled to the range 0 to 255.
        The alpha channel is synthesized if necessary
        (with a small speed penalty).
        r)rl�asRGBArKrrr�asRGBA8s
zReader.asRGBA8cs�|��\�}�}|drtd��|ds�|�|fSd|d<d|d<|ddkr-d	d
��ndd
�����fdd
�}�||�|fS)a
        Return image as RGB pixels.
        RGB colour images are passed through unchanged;
        greyscales are expanded into RGB triplets
        (there is a small speed overhead for doing this).

        An alpha channel in the source image will raise an exception.

        The return values are as for the :meth:`read` method except that
        the *info* reflect the returned pixels, not the source image.
        In particular,
        for this method ``info['greyscale']`` will be ``False``.
        rbz0will not convert image with alpha channel to RGBrBFr1rmrdrcSstddg�S)Nrrrrrrr�newarray=szReader.asRGB.<locals>.newarraycSs
tdg�S)Nr�r�rrrrrr@r/c3s@��D]}��d�}td�D]	}|||dd�<q|VqdS)Nr1�r)rtr�r:�rrr�r rr�iterrgbCs��zReader.asRGB.<locals>.iterrgb)rgrE)rLr!r�rvrrurrn%s
zReader.asRGBcs
|��\}}�}|dr|ds||�|fSd|ddk}d|dd}t�d||�d	|�|ddkr?�fd
d��n�fdd��|drU|drU��fd
d�}n|dra��fdd�}n|dsi|drkJ���fdd�}d|d<d|d<d	|d<|||�|fS)a�
        Return image as RGBA pixels.
        Greyscales are expanded into RGB triplets;
        an alpha channel is synthesized if necessary.
        The return values are as for the :meth:`read` method except that
        the *info* reflect the returned pixels, not the source image.
        In particular, for this method
        ``info['greyscale']`` will be ``False``, and
        ``info['alpha']`` will be ``True``.
        rbrBryrdrrr�=rcs
td��S)Nrrr��	maxbufferrrrr_r/zReader.asRGBA.<locals>.newarraycst��Srrsrrxrrrrbsc3�&��D]
}��}t||�|VqdSr)�convert_la_to_rgba�rtr��rrr�rr�convertgs�
�zReader.asRGBA.<locals>.convertc3rzr)�convert_l_to_rgbar|r}rrr~q��
�c3rzr)�convert_rgb_to_rgbar|r}rrr~zr�TFrm)rgr�r�)rLr r!r�r�ror~r)ryrrr�rrpKs&z
Reader.asRGBA)NNNN)Fr)rU) rHrNrOrSrrr�r�rrr rr*rr.rr-r=r?rBrCrDrErIr�rTr7rgrlrorqrnrprrrrr+s<

1,54


3



A
r&rccs6�t��}|D]
}t|�|��Vqt|���VdS)z�
    `data_blocks` should be an iterable that
    yields the compressed data (from the ``IDAT`` chunks).
    This yields decompressed byte strings.
    N)r��
decompressobjr�rOr�)�data_blocks�dr�rrrrO�s
�
rOcCsp|dvr
td|��|dvrtd|��|d@r$|dkr$td||f��|dkr4|dvr6td	||f��d
Sd
S)z�
    Check that `bitdepth` and `colortype` are both valid,
    and specified in a valid combination.
    Returns (None) if valid, raise an Exception if not valid.
    r�zinvalid bit depth %dr\zinvalid colour type %drrz�Indexed images (colour type %d) cannot have bitdepth > 8 (bit depth %d). See http://www.w3.org/TR/2003/REC-PNG-20031110/#table111 .)rr1zvIllegal combination of bit depth (%d) and colour type (%d). See http://www.w3.org/TR/2003/REC-PNG-20031110/#table111 .N)rQ)rd�	colortyperrrr9�s"�����r9c	Cs6zt|�|k}WnttfyYdSw|o|dkS)zA non-negative integer.Fr)r6r?�
ValueError)r-�
is_integerrrrr@�s�r@cCsDd}t|t|��D]}||}||}||d@||<|d7}q	dS)zUndo sub filter.rr2rN�rr3)�filter_unitrrr�air:r-r�rrrr�s
�rcCs6tt|��D]}||}||}||d@||<qdS)�Undo up filter.r2Nr�)r�rrrr:r-rprrrr�s
�rc	Csb|}tt|��D]%}||}|dkrd}n||}||}|||d?d@||<|d7}q	dS)r�rrr2Nr�)	r�rrrr�r:r-r�rprrrr
�s
�r
cCs�|}tt|��D]S}||}|dkrd}}n||}||}||}	||	|}
t|
|�}t|
|	�}t|
|�}
||krG||
krG|}n	||
krN|	}n|}||d@||<|d7}q	dS)zUndo Paeth filter.rr2rN)rr3�abs)r�rrrr�r:r-r�rArpr8�pa�pb�pc�prrrrr�s(

�rcCsBtd�D]}|ddd�||dd�<q|ddd�|ddd�<dS)Nr1rrrrrt�rtrr:rrrr{�sr{cCs td�D]	}|||dd�<qdS)z�
    Convert a grayscale image to RGBA.
    This method assumes the alpha channel in result is
    already correctly initialized.
    r1Nrrtr�rrrr	s�rcCs*td�D]}||dd�||dd�<qdS)z�
    Convert an RGB image to RGBA.
    This method assumes the alpha channel in result is
    already correctly initialized.
    r1Nrrtr�rrrr�	s�r�cCstjjS)z)
    A sys.stdin that returns bytes.
    )�sys�stdin�bufferrrrr�binary_stdin	sr�cCs:tjj}tjdkrddl}ddl}|�tj��|j�|S)z*
    A sys.stdout that accepts bytes.
    �win32rN)	r��stdoutr��platform�msvcrt�os�setmode�fileno�O_BINARY)r�r�r�rrr�
binary_stdout"	s
r�cCs|dkrt�St|d�S)N�-r�)r�r�)�pathrrr�cli_open2	s
r�cCsttt�dS)z:
    Run command line PNG.
    Which reports version.
    N)�print�__version__�__file__)�argvrrr�main8	sr��__main__)r�)r�)ArSr��collectionsr�rzr�rX�rer�r�rr�r�__all__r�r�rr$�
namedtuplerQr+r.r<r>rD�	ExceptionrErQr4rUrVrr�rr�r�r�r�r_�compile�
IGNORECASEr�r�	fromarrayrrrOr9r@rrr
rr{rr�r�r�r�r�rHr�r�r��stderrrrrr�<module>s� 	"
4!"	346`		

���
@ Telegram