U
    ûŸ?iÍa  ã                   @  sh  d dl mZ d dlZd dlZd dlZd dlZd dlZd dlmZm	Z	m
Z
 ddlmZ ddlmZ ddlmZ dZd	Zd
ZddddddœZddddœdd„Zdddœdd„Zdd„ ZG dd„ de
ƒZG dd„ dejƒZG d d!„ d!ƒZG d"d#„ d#eƒZG d$d%„ d%ƒZd8d&d'œd(d)„Zd9d*d+œd,d-„Zd.d/„ ZG d0d1„ d1ƒZ G d2d3„ d3ƒZ!G d4d5„ d5e!ƒZ"G d6d7„ d7e!ƒZ#dS ):é    )ÚannotationsN)ÚIOÚAnyÚ
NamedTupleé   )ÚImage)Ú	deprecate)Úis_pathi   i   Fzimage buffer overrun errorzdecoding errorzunknown errorzbad configurationzout of memory error)éÿÿÿÿéþÿÿÿéýÿÿÿéøÿÿÿi÷ÿÿÿÚintÚboolÚOSError)ÚerrorÚencoderÚreturnc                C  sj   zt j | ¡}W n tk
r.   t | ¡}Y nX |sJ|r<dnd› d| › �}|d|rVdnd› d�7 }t|ƒS )Nr   Údecoderz error z when ÚwritingÚreadingz image file)r   ÚcoreÚgetcodecstatusÚAttributeErrorÚERRORSÚgetr   )r   r   Úmsg© r   úM/var/www/html/mysite/school/venv/lib/python3.8/site-packages/PIL/ImageFile.pyÚ_get_oserrorD   s    r   )r   r   c                 C  s   t dddd� t| dd�‚d S )NÚraise_oserroré   z€It is only useful for translating error codes returned by a codec's decode() method, which ImageFile already does automatically.)ÚactionF©r   )r   r   )r   r   r   r   r    O   s    ýr    c                 C  s   | d S )Né   r   )Útr   r   r   Ú	_tilesortY   s    r&   c                   @  s.   e Zd ZU ded< ded< ded< ded< d	S )
Ú_TileÚstrZ
codec_nameútuple[int, int, int, int]Úextentsr   Úoffsetztuple[Any, ...] | str | NoneÚargsN)Ú__name__Ú
__module__Ú__qualname__Ú__annotations__r   r   r   r   r'   ^   s   
r'   c                      sv   e Zd ZdZd‡ fdd„	Zddœdd„Z‡ fd	d
„Zddœdd„Zdd„ Zddœdd„Z	ddœdd„Z
dd„ Z‡  ZS )Ú	ImageFilez*Base class for image file format handlers.Nc                   s  t ƒ  ¡  d| _d | _d | _d| _d| _t| _t	|ƒrPt
|dƒ| _|| _d| _n|| _|| _d | _zxz|  ¡  W n8 tttttjfk
r¨ } zt|ƒ|‚W 5 d }~X Y nX | jrÌ| jd dksÌ| jd dkrØd}t|ƒ‚W n( tk
�r   | jrü| j ¡  ‚ Y nX d S )Nr   r   r   ÚrbTznot identified by this driver)ÚsuperÚ__init__Ú
_min_frameÚcustom_mimetypeÚtileÚreadonlyÚdecoderconfigÚMAXBLOCKÚdecodermaxblockr	   ÚopenÚfpÚfilenameÚ_exclusive_fpÚ_openÚ
IndexErrorÚ	TypeErrorÚKeyErrorÚEOFErrorÚstructr   ÚSyntaxErrorÚmodeÚsizeÚBaseExceptionÚclose)Úselfr=   r>   Úvr   ©Ú	__class__r   r   r4   m   s@    
û"
zImageFile.__init__z
str | None©r   c                 C  s,   | j r| j S | jd k	r(tj | j ¡ ¡S d S ©N)r6   Úformatr   ÚMIMEr   Úupper©rK   r   r   r   Úget_format_mimetype�   s
    
zImageFile.get_format_mimetypec                   s   g | _ tƒ  |¡ d S rP   )r7   r3   Ú__setstate__)rK   ÚstaterM   r   r   rV   ¤   s    zImageFile.__setstate__ÚNonec                 C  s   | j r| j ¡  d| _dS )zCheck file integrityN)r?   r=   rJ   rT   r   r   r   Úverify¨   s    
zImageFile.verifyc                 C  sÌ  | j dkrd}t|ƒ‚tj | ¡}| j s,|S d| _| joDt| j ƒdk}|oTttdƒ }d}z| j	}d}W n t
k
r„   | jj}Y nX z| j}d}W n t
k
r°   | jj}Y nX |�rÐ| j d \}}}	}
t|
tƒrÞ|
ddf}
|dk�rÐt|
ƒdk�rÐ|
d | jk�rÐ|
d tjk�rÐz–ddl}t| jƒ�}|j| ¡ d|jd	�| _W 5 Q R X |	| jd |
d   | j ¡ k�r|d
}t|ƒ‚tj | j| j||	|
¡| _d}| j�rªd| j_W n" t
ttfk
�rÎ   d| _Y nX |  ¡  d}| j�sh| j jt d� z
| j!}W n t
k
�r   d}Y nX dd„ t" #| j dd„ ¡D ƒ| _ | j D �](\}}}	}
||	ƒ t $| j||
| j%¡}zò| '| j|¡ |j(�rš| )| j¡ | *d¡d }n¼|}z|| j+ƒ}W nJ t,t-j.fk
�rö } z$t/�rØW Y ¢�qVnd}t|ƒ|‚W 5 d}~X Y nX |�s"t/�r
�qVndt|ƒ› d�}t|ƒ‚|| }| *|¡\}}|dk �rF�qV||d… }�qžW 5 | &¡  X �q<g | _ || _0|  1¡  | j2�r–| j3�r–| j 4¡  d| _| j�sÀt/�sÀ|dk �rÀt5|dd�‚tj | ¡S )z"Load image data based on tile listNzcannot load this imager   Zpypy_version_infor   FÚrawé   )Úaccesszbuffer is not large enoughr   ©Úkeyó    c                 S  s   g | ]\}}t |ƒd  ‘qS )r
   )Úlist)Ú.0Ú_Ztilesr   r   r   Ú
<listcomp>ý   s   ÿz"ImageFile.load.<locals>.<listcomp>c                 S  s   | d | d | d fS )Nr   r   r[   r   ©r7   r   r   r   Ú<lambda>   r_   z ImageFile.load.<locals>.<lambda>zimage file is truncatedzimage file is truncated (z bytes not processed)r#   )6r7   r   r   ÚloadÚmapr>   ÚlenÚhasattrÚsysÚ	load_readr   r=   ÚreadÚ	load_seekÚseekÚ
isinstancer(   rG   Ú	_MAPMODESÚmmapr<   ÚfilenoÚACCESS_READrH   r   Ú
map_bufferÚimÚpaletteÚdirtyÚImportErrorÚload_prepareÚsortr&   Ztile_prefixÚ	itertoolsÚgroupbyÚ_getdecoderr9   ÚcleanupÚsetimageÚpulls_fdÚsetfdÚdecoder;   rA   rE   r   ÚLOAD_TRUNCATED_IMAGESr8   Úload_endr?   Ú!_close_exclusive_fp_after_loadingrJ   r   )rK   r   ZpixelZuse_mmapr8   rl   rn   Údecoder_namer*   r+   r,   rq   r=   Zerr_codeÚprefixr   ÚbÚsÚeÚnr   r   r   rf   ±   sÖ    


ÿ
þýü""    ÿ

 ÿþ   ÿÿ

zImageFile.loadc                 C  sP   | j r"| j j| jks"| j j| jkr6tj | j| j¡| _ | jdkrLtj | ¡ d S )NÚP)ru   rG   rH   r   r   Únewrf   rT   r   r   r   ry   <  s    "
zImageFile.load_preparec                 C  s   d S rP   r   rT   r   r   r   r„   D  s    zImageFile.load_endc                 C  sF   || j k s.t| dƒr| jd ks:|| j| j  kr:d}t|ƒ‚|  ¡ |kS )NÚ	_n_framesz attempt to seek outside sequence)r5   ri   rŽ   Ún_framesrD   Útell)rK   Úframer   r   r   r   Ú_seek_checkP  s    ÿûûú	zImageFile._seek_check)NN)r-   r.   r/   Ú__doc__r4   rU   rV   rY   rf   ry   r„   r’   Ú__classcell__r   r   rM   r   r1   j   s   0	 r1   c                   @  s2   e Zd Zdddœdd„Zejdddœdd„ƒZd	S )
ÚStubHandlerÚStubImageFilerX   )ru   r   c                 C  s   d S rP   r   ©rK   ru   r   r   r   r<   a  s    zStubHandler.openzImage.Imagec                 C  s   d S rP   r   r—   r   r   r   rf   d  s    zStubHandler.loadN)r-   r.   r/   r<   ÚabcÚabstractmethodrf   r   r   r   r   r•   `  s   r•   c                   @  s4   e Zd ZdZddœdd„Zdd„ Zddœd	d
„ZdS )r–   z±
    Base class for stub image loaders.

    A stub loader is an image loader that can identify files of a
    certain format, but relies on external code to load the file.
    rX   rO   c                 C  s   d}t |ƒ‚d S )Nz+StubImageFile subclass must implement _open©ÚNotImplementedError©rK   r   r   r   r   r@   q  s    zStubImageFile._openc                 C  sT   |   ¡ }|d kr&d| j› d�}t|ƒ‚| | ¡}|d k	s<t‚|j| _|j| _| ¡ S )Nzcannot find loader for this z file)Ú_loadrQ   r   rf   ÚAssertionErrorrN   Ú__dict__)rK   Úloaderr   Úimager   r   r   rf   u  s    
zStubImageFile.loadzStubHandler | Nonec                 C  s   d}t |ƒ‚dS )z (Hook) Find actual image loader.z+StubImageFile subclass must implement _loadNrš   rœ   r   r   r   r�   �  s    zStubImageFile._loadN)r-   r.   r/   r“   r@   rf   r�   r   r   r   r   r–   i  s   r–   c                   @  sh   e Zd ZU dZdZdZded< dZdZdZ	dZ
ddœdd	„Zd
d„ Zdd„ Zdddœdd„Zdd„ ZdS )ÚParserzj
    Incremental image parser.  This class implements the standard
    feed/close consumer interface.
    NzImage.Image | Noner¡   r   rX   rO   c                 C  s   | j dkstdƒ‚dS )zµ
        (Consumer) Reset the parser.  Note that you can only call this
        method immediately after you've created a parser; parser
        instances cannot be reused.
        Nzcannot reuse parsers)Údatarž   rT   r   r   r   Úreset”  s    zParser.resetc              	   C  sÌ  | j r
dS | jdkr|| _n| j| | _| jrÒ| jdkrztt| jƒ| jƒ}| j|d… | _| j| | _| jdksv| jszdS | j | j¡\}}|dk rÀd| _d| _ |dk r¼d| _t|dd�‚ndS | j|d… | _nö| jrÚnîz&t	 
| j¡�}t |¡}W 5 Q R X W n tk
�r   Y n²X t|dƒ�p,t|dƒ}|�sDt|jƒdk�rLd| _nv| ¡  |jd \}}}	}
g |_t |j||
|j¡| _| j |j|¡ |	| _| jt| jƒk�rÂ| j| jd… | _d| _|| _dS )z¦
        (Consumer) Feed data to the parser.

        :param data: A string buffer.
        :exception OSError: If the parser failed to parse the image file.
        Nr   r   Fr#   rm   rk   )Úfinishedr£   r   r+   Úminrh   r‚   r¡   r   ÚioÚBytesIOr   r<   r   ri   r7   ry   r}   rG   r9   r   ru   )rK   r£   Úskipr‹   rŠ   r=   ru   ÚflagÚdÚoÚar   r   r   Úfeedœ  sR    	

zParser.feedc                 C  s   | S rP   r   rT   r   r   r   Ú	__enter__è  s    zParser.__enter__Úobject)r,   r   c                 G  s   |   ¡  d S rP   )rJ   ©rK   r,   r   r   r   Ú__exit__ë  s    zParser.__exit__c              	   C  s‚   | j r.|  d¡ d | _| _ | js.d}t|ƒ‚| js@d}t|ƒ‚| jr|t | j¡�$}zt	 
|¡| _W 5 | j ¡  X W 5 Q R X | jS )a  
        (Consumer) Close the stream.

        :returns: An image object.
        :exception OSError: If the parser failed to parse the image file either
                            because it cannot be identified or cannot be
                            decoded.
        r_   Nzimage was incompletezcannot parse this image)r   r®   r£   r¥   r   r¡   r§   r¨   rf   r   r<   )rK   r   r=   r   r   r   rJ   î  s    

zParser.close)r-   r.   r/   r“   Úincrementalr¡   r0   r£   r   r+   r¥   r¤   r®   r¯   r²   rJ   r   r   r   r   r¢   ‡  s   
Lr¢   rX   rO   c              
   C  s°   |   ¡  t| dƒsd| _|jtd� tt|| jd d ƒ}z$| ¡ }| 	¡  t
| ||||ƒ W n: ttjfk
r˜ } zt
| |||d|ƒ W 5 d}~X Y nX t|dƒr¬| 	¡  dS )z«Helper to save image based on tile list

    :param im: Image object.
    :param fp: File object.
    :param tile: Tile list.
    :param bufsize: Optional buffer size
    Úencoderconfigr   r]   r   é   NÚflush)rf   ri   r´   rz   r&   Úmaxr:   rH   rr   r¶   Ú_encode_tiler   r§   ÚUnsupportedOperation)ru   r=   r7   ÚbufsizeÚfhÚexcr   r   r   Ú_save  s    	
$
r½   zlist[_Tile]rd   c              	   C  sÈ   |D ]¾\}}}}	|dkr"|  |¡ t | j||	| j¡}
z€|
 | j|¡ |
jrd|
 	|¡ |
 
¡ d }n:|r’|
 |¡dd … \}}| |¡ |rhqžqhn|
 ||¡}|dk r´t|dd�|‚W 5 |
 ¡  X qd S )Nr   r   Tr#   )rn   r   Ú_getencoderrG   r´   r~   r   ru   Ú	pushes_fdr�   Úencode_to_pyfdÚencodeÚwriteÚencode_to_filer   )ru   r=   r7   rº   r»   r¼   Úencoder_namer*   r+   r,   r   Úerrcoder£   r   r   r   r¸   ,  s$    


r¸   c                 C  s¤   |dkrdS |t kr:|  |¡}t|ƒ|k r6d}t|ƒ‚|S g }|}|dkrx|  t|t ƒ¡}|s`qx| |¡ |t|ƒ8 }qBtdd„ |D ƒƒ|k ršd}t|ƒ‚d |¡S )a»  
    Reads large blocks in a safe way.  Unlike fp.read(n), this function
    doesn't trust the user.  If the requested size is larger than
    SAFEBLOCK, the file is read block by block.

    :param fp: File handle.  Must implement a <b>read</b> method.
    :param size: Number of bytes to read.
    :returns: A string containing <i>size</i> bytes of data.

    Raises an OSError if the file is truncated and the read cannot be completed

    r   r_   zTruncated File Readc                 s  s   | ]}t |ƒV  qd S rP   )rh   )ra   r«   r   r   r   Ú	<genexpr>d  s     z_safe_read.<locals>.<genexpr>)Ú	SAFEBLOCKrl   rh   r   r¦   ÚappendÚsumÚjoin)r=   rH   r£   r   Zremaining_sizeÚblockr   r   r   Ú
_safe_readG  s(    

rÌ   c                   @  s(   e Zd Zddœdd„Zddœdd„ZdS )	ÚPyCodecStaterX   rO   c                 C  s   d| _ d| _d| _d| _d S )Nr   )ÚxsizeÚysizeÚxoffÚyoffrT   r   r   r   r4   k  s    zPyCodecState.__init__r)   c                 C  s    | j | j| j | j | j| j fS rP   )rÐ   rÑ   rÎ   rÏ   rT   r   r   r   r*   q  s    zPyCodecState.extentsN)r-   r.   r/   r4   r*   r   r   r   r   rÍ   j  s   rÍ   c                   @  sN   e Zd ZU ded< dd„ Zdd„ Zddœd	d
„Zdd„ Zddddœdd„ZdS )ÚPyCodeczIO[bytes] | NoneÚfdc                 G  s(   d | _ tƒ | _d | _|| _|  |¡ d S rP   )ru   rÍ   rW   rÓ   rG   Úinit)rK   rG   r,   r   r   r   r4   x  s
    zPyCodec.__init__c                 C  s
   || _ dS )z˜
        Override to perform codec specific initialization

        :param args: Array of args items from the tile entry
        :returns: None
        N)r,   r±   r   r   r   rÔ     s    zPyCodec.initrX   rO   c                 C  s   dS )zT
        Override to perform codec specific cleanup

        :returns: None
        Nr   rT   r   r   r   r~   ˆ  s    zPyCodec.cleanupc                 C  s
   || _ dS )z�
        Called from ImageFile to set the Python file-like object

        :param fd: A Python file-like object
        :returns: None
        N)rÓ   )rK   rÓ   r   r   r   r�   �  s    zPyCodec.setfdNz tuple[int, int, int, int] | None)r*   r   c                 C  sÞ   || _ |r|\}}}}nd\}}}}|dkrJ|dkrJ| j j\| j_| j_n(|| j_|| j_|| | j_|| | j_| jjdksŠ| jjdkr–d}t|ƒ‚| jj| jj | j jd ksÎ| jj| jj | j jd krÚd}t|ƒ‚dS )zø
        Called from ImageFile to set the core output image for the codec

        :param im: A core image object
        :param extents: a 4 tuple of (x0, y0, x1, y1) defining the rectangle
            for this tile
        :returns: None
        )r   r   r   r   r   zSize cannot be negativer   z Tile cannot extend outside imageN)ru   rH   rW   rÎ   rÏ   rÐ   rÑ   Ú
ValueError)rK   ru   r*   Úx0Úy0Úx1Úy1r   r   r   r   r   ™  s&    ÿþzPyCodec.setimage)N)	r-   r.   r/   r0   r4   rÔ   r~   r�   r   r   r   r   r   rÒ   u  s   
		rÒ   c                   @  sH   e Zd ZdZdZeddœdd„ƒZddd	œd
d„Zddddœdd„ZdS )Ú	PyDecoderzË
    Python implementation of a format decoder. Override this class and
    add the decoding logic in the :meth:`decode` method.

    See :ref:`Writing Your Own File Codec in Python<file-codecs-py>`
    Fr   rO   c                 C  s   | j S rP   )Ú	_pulls_fdrT   r   r   r   r€   É  s    zPyDecoder.pulls_fdÚbytesútuple[int, int])Úbufferr   c                 C  s   d}t |ƒ‚dS )a=  
        Override to perform the decoding process.

        :param buffer: A bytes object with the data to be decoded.
        :returns: A tuple of ``(bytes consumed, errcode)``.
            If finished with decoding return -1 for the bytes consumed.
            Err codes are from :data:`.ImageFile.ERRORS`.
        zunavailable in base decoderNrš   )rK   rÞ   r   r   r   r   r‚   Í  s    	zPyDecoder.decodeNrX   )r£   r   c                 C  sz   |s
| j }t | j d|¡}| jdk	s(t‚| | j| j ¡ ¡ | |¡}|d dkr^d}t	|ƒ‚|d dkrvd}t	|ƒ‚dS )a  
        Convenience method to set the internal image from a stream of raw data

        :param data: Bytes to be set
        :param rawmode: The rawmode to be used for the decoder.
            If not specified, it will default to the mode of the image
        :returns: None
        rZ   Nr   znot enough image datar   zcannot decode image data)
rG   r   r}   ru   rž   r   rW   r*   r‚   rÕ   )rK   r£   Úrawmoder«   r‰   r   r   r   r   Ú
set_as_rawÙ  s    

zPyDecoder.set_as_raw)N)	r-   r.   r/   r“   rÛ   Úpropertyr€   r‚   rà   r   r   r   r   rÚ   ¿  s   rÚ   c                   @  sL   e Zd ZdZdZeddœdd„ƒZddd	œd
d„Zddœdd„Zdd„ Z	dS )Ú	PyEncoderzË
    Python implementation of a format encoder. Override this class and
    add the decoding logic in the :meth:`encode` method.

    See :ref:`Writing Your Own File Codec in Python<file-codecs-py>`
    Fr   rO   c                 C  s   | j S rP   )Ú
_pushes_fdrT   r   r   r   r¿   ü  s    zPyEncoder.pushes_fdr   ztuple[int, int, bytes])rº   r   c                 C  s   d}t |ƒ‚dS )a   
        Override to perform the encoding process.

        :param bufsize: Buffer size.
        :returns: A tuple of ``(bytes encoded, errcode, bytes)``.
            If finished with encoding return 1 for the error code.
            Err codes are from :data:`.ImageFile.ERRORS`.
        zunavailable in base encoderNrš   )rK   rº   r   r   r   r   rÁ      s    	zPyEncoder.encoderÝ   c                 C  s@   | j s
dS |  d¡\}}}|r8| jdk	s,t‚| j |¡ ||fS )zø
        If ``pushes_fd`` is ``True``, then this method will be used,
        and ``encode()`` will only be called once.

        :returns: A tuple of ``(bytes consumed, errcode)``.
            Err codes are from :data:`.ImageFile.ERRORS`.
        )r   r   r   N)r¿   rÁ   rÓ   rž   rÂ   )rK   Úbytes_consumedrÅ   r£   r   r   r   rÀ     s    zPyEncoder.encode_to_pyfdc                 C  s<   d}|dkr8|   |¡\}}}|dkr| ||d… ¡ q|S )zì
        :param fh: File handle.
        :param bufsize: Buffer size.

        :returns: If finished successfully, return 0.
            Otherwise, return an error code. Err codes are from
            :data:`.ImageFile.ERRORS`.
        r   N)rÁ   rÂ   )rK   r»   rº   rÅ   ÚstatusÚbufr   r   r   rÃ     s    	zPyEncoder.encode_to_fileN)
r-   r.   r/   r“   rã   rá   r¿   rÁ   rÀ   rÃ   r   r   r   r   râ   ò  s   râ   )r   )N)$Ú
__future__r   r˜   r§   r{   rE   rj   Útypingr   r   r   Ú r   Ú
_deprecater   Ú_utilr	   r:   rÇ   rƒ   r   r   r    r&   r'   r1   r•   r–   r¢   r½   r¸   rÌ   rÍ   rÒ   rÚ   râ   r   r   r   r   Ú<module>   sF   û
 w	 
#J3