serveur-d-authentification/venv/lib/python3.10/site-packages/PIL/__pycache__/ImageFile.cpython-310.pyc

o
<00>Q<EFBFBD>j<EFBFBD>t<00>@
s<>
dd
lm
Z

ddlZddlZddlZddlZddlZddlZddlm	Z	m
Z
mZmZ
ddl
mZmZ
ddlmZmZ
dZerDddlmZ
e<05>e<17>
Zd	Z	d
ZdZ	ddd
ddd<10>Z	dCdd<18>ZdDdd<1C>ZGdd<1A>de<0B>ZGdd<1F>dej<0F>Z Gd d!<21>d!ej!<21>Z"Gd"d#<23>d#e ej#d$<24>Z$Gd%d&<26>d&<26>Z%dEdFd/d0<64>Z&	dGdHd5d6<64>Z'dId9d:<3A>Z(Gd;d<<3C>d<<3C>Z)Gd=d><3E>d><3E>Z*Gd?d@<40>d@e*<2A>Z+GdAdB<64>dBe*<2A>Z,dS)J<>)
<01>annotationsN)<04>IO<49>Any<6E>
NamedTuple<EFBFBD>cast<73>
)<02>ExifTags<67>Image)<02>
DeferredError<6F>is_pathF)
<01>StrOrBytesPathi
izimage buffer overrun errorzdecoding errorz
unknown errorzbad configurationzout of memory error)<05><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>i<EFBFBD><69><EFBFBD><EFBFBD><EFBFBD>error<6F>int<6E>encoder<65>bool<6F>return<72>OSErrorc

C
shztj
<01>|<00>
}Wnty


t<04>|<00>
}Yn
w|s$|
rd
n
d<02>d|<00><00>}|d|
r*dn
d<06>d<07>7}t|<02>
S)Nr<00>decoderz error z when <20>writing<6E>readingz image file)r	<00>core<72>getcodecstatus<75>AttributeError<6F>ERRORS<52>getr)rr<00>msg<73>r <00>p/home/sorel/systeme_gestion_cerfig/serveur-d-authentification/venv/lib/python3.10/site-packages/PIL/ImageFile.py<70>_get_oserrorVs



<02>


r"<00>
t<>_Tilec

C
s|d
S)N<>r )
r#r r r!<00>	_tilesortasr&c@
s6eZ
dZUd
ed<ded<dZded<dZd	ed
<dS)r$<00>str<74>
codec_name<EFBFBD> tuple[int, int, int, int] | None<6E>extentsr
r<00>offsetNztuple[Any, ...] | str | None<6E>args)<06>__name__<5F>
__module__<EFBFBD>__qualname__<5F>__annotations__r+r,r r r r!r$fs





c
s<>eZ
dZd
Z	d1d2<64>f
d	d
<EFBFBD>
Zd3dd<0C>Zd4d
d<0E>Zd3dd<10>Zd5dd<14>Zd3<64>f
dd<16>Z	d6dd<19>Z
d7dd<1C>Zd8<64>f
dd<1F>Zd9<64>f
d!d"<22>Z
d3d#d$<24>Zd:d&d'<27>Zd3d(d)<29>Zd3d*d+<2B>Zd;d/d0<64>Z<12>ZS)<<3C>	ImageFilez*Base class for image file format handlers.N<>fp<66>StrOrBytesPath | IO[bytes]<5D>filename<6D>str | bytes | Noner<00>Nonec
s:
t<00><00>
<01>
d
|_d|_g|_	d|_d|_t|_|
|
t	|
<01>
r0t
|
d<04>|_t<0C>
|
<01>
|_d|_nttt|
<01>|_|du
r>|n
d|_d|_zHz|<00><13>
t|t<15>rZ|<00><16>}rZ|<03>
|<00>

Wntttttjfyr
}
zt|<04>
|<04>d}~w
w|jr<>|jd
d
k
s<>|jdd
k
r<>d}t|<05>
<01>
WdSt y<>


|jr<>|j<0B>!<21>
<00>w)	Nr
rr <00>rbT<62>Fznot identified by this driver)"<22>super<65>__init__<5F>
_min_frame<EFBFBD>custom_mimetype<70>tile<6C>readonly<6C>
decoderconfig<69>MAXBLOCK<43>decodermaxblockr<00>openr2<00>os<6F>fspathr4<00>
_exclusive_fprr<00>bytes<65>_open<65>
isinstance<EFBFBD>
StubImageFile<6C>_load<61>
IndexError<EFBFBD>	TypeError<6F>KeyError<6F>EOFError<6F>structr<00>SyntaxError<6F>mode<64>size<7A>
BaseException<6F>close)<06>selfr2r4<00>loader<65>
vr<00>
<01>	__class__r r!r:usV













<04>





<0C>
<08><02>"	

<06>


<02>zImageFile.__init__c


C
<01>dS<00>
Nr <00>
rUr r r!rG<00><00>
zImageFile._openc


C
<01>|Sr[r r\r r r!<00>	__enter__<5F>r]zImageFile.__enter__c

C
sTt|d
d<02>rt
|jt<03>s|j|jkr|j<02><05>
ttd<03>
<01>
|_|jr(|j<04><05>
dSdS)N<>_fpFzOperation on closed image)<07>getattrrHr`r
r2rT<00>
ValueErrorr\r r r!<00>	_close_fp<66>s






<04>zImageFile._close_fpr,<00>objectc
G
st|d
d<02>r
|<00>
<01>
d|_dS)NrEF)rarcr2<00>rUr,r r r!<00>__exit__<5F>s



zImageFile.__exit__c


sRz	|<00><00>
d
|_
Wnty!
}

zt<03>d|
<01>
WYd
}
~
nd
}
~
w
wt<05><00><06>
d
S)a<>

        Closes the file pointer, if possible.

        This operation will destroy the image core and release its memory.
        The image data will be unusable afterward.

        This function is required to close images that have multiple frames or
        have not had their file read and closed by the
        :py:meth:`~PIL.Image.Image.load` method. See :ref:`file-handling` for
        more information.
        NzError closing: %s)rcr2<00>	Exception<6F>logger<65>debugr9rT)rUrrXr r!rT<00>s




<08><02>zImageFile.close<73>list[ImageFile]c
	
s<>
g}
|<00><00><00>g}t
jj<03>vr'<27>t
jj}|r't|t<05>s|f
}<03>f
d
d<02>|D<00>
}<02><00>t
jj<08>
}|rG|<04>	t
jj
<EFBFBD>
rG<72>jdu
s>J<00>
|<02>|<04>jj
f<02>

d}|D]<5D>\}}|jdu
sVJ<00>
|j<0E><0F>}|dura|}|j}	|du
r<>|<06>	t
jj
<EFBFBD>
}
|
du
r<>|
t|dd<04>7}
|j<0E>|
<EFBFBD>

|<06>	t
jj<12>
}t|t<13>s<>J<00>
|j<0E>|<0B>
}t<15>|<0C>
}	t<17>|	<09>
<01>*}
ddlm}
|
dur<>t|
|j<1B>r<>|g
|
_|
<0A>d<04>

|
<0A><1E>
|
<01>|
<0A>

Wd<00>
n1s<>w



Y
qK|du
r<>|jdu
s<>J<00>
|j<0E>|<05>

|
S)Nc

sg|]	}
<01><00>|
<01>
|
f<02>qSr )
<01>
_get_ifd_dict)<02>.0<EFBFBD>
subifd_offset<65>
<01>exifr r!<00>
<listcomp><3E>s<0C><06>z.ImageFile.get_child_images.<locals>.<listcomp><3E>_exif_offsetr
r)
<01>TiffImagePlugin)<1F>getexifr<00>Base<73>SubIFDsrH<00>tuple<6C>get_ifd<66>IFD<46>IFD1r<00>JpegIFOffset<65>_info<66>append<6E>nextr2<00>tellra<00>seek<65>JpegIFByteCountr<00>read<61>io<69>BytesIOr	rBr8rr<00>
TiffImageFile<6C>
_frame_pos<EFBFBD>_seek<65>load)rU<00>child_images<65>ifds<64>subifd_offsets<74>ifd1r+<00>ifd<66>
ifd_offset<EFBFBD>current_offsetr2<00>thumbnail_offset<65>length<74>data<74>imrrr rnr!<00>get_child_images<65>s\










<06>




















<04>



<1C><02>


zImageFile.get_child_images<65>
str | Nonec

C
s,|jr|jS|j
du
rtj<03>|j
<01><05><00>
SdSr[)r<<00>formatr	<00>MIMEr<00>upperr\r r r!<00>get_format_mimetype

s






zImageFile.get_format_mimetype<70>	list[Any]c


st<00><00>
<01>|jg
Sr[)r9<00>__getstate__r4r\rXr r!r<>
s
zImageFile.__getstate__<5F>statec
s,g|_t
|
<01>
d
kr|
d
|_t<03><00>|
<01>

dS)N<>)r=<00>lenr4r9<00>__setstate__)rUr<>rXr r!r<>
s




zImageFile.__setstate__c

C
s |jr|j
r|j
<01><02>
d
|_
d
S)zCheck file integrityN)rEr2rTr\r r r!<00>verify
s



zImageFile.verify<66>Image.core.PixelAccess | Nonec
C
s<>|js|j
d
urd}
t|
<01>
<01>
tj<03>|<00>
}|js|Sd
|_|jo%t|j<00>
dk}|jd
u
s-J<00>
d}t	|d<05>r:|j
}d}n|jj}t	|d<07>rI|j}d}n|jj
}|r<>|jd\}}}	}
t|
t<0F>rb|
ddf}
|dkr<>t|
t<10>r<>t|
<EFBFBD>
d	kr<>|
d|jkr<>|
dtjvr<>|	dkr<>d
}
t|
<01>
<01>
zSdd
l}t|j<06>
<01>}|j|<0C><16>d|jd<0B>|_Wd
<00>
n1s<>w



Y
|	|jd|
d|j<05><18>kr<>d}
t|
<01>
<01>
tj<19>|j|j||	|
<EFBFBD>|_d}|jr<>d|j_Wntttfy<>


d
|_Yn
w|<00> <20>
d
}
|j<05>
s<>|jj!t"d<0E>

t#|dd<10>}dd<12>t$<24>%|jdd<14><00>D<00>
|_t&|j<00>
D]<5D>\}\}}}	}
||	<09>

t<03>'|j||
|j(<28>}z<>|<10>)|j|<08>
|j*<2A>
rG|<10>+|j<08>

|<10>,d<10>
d}
nt|}	|j-}|dt|j<00>
k<00>
rh|j|dj.}||	k<04>
rh||	}z||<12>
}Wn t/t0j1f<02>
y<>
}
zt2<74>
r<>WYd
}~n8d}
t|
<01>
|<15>d
}~w
w|<14>
s<>t2<74>
r<>n%dt|<11>
<01>d<18>}
t|
<01>
<01>
||}|<10>,|<11>
\}}
|dk<00>
r<>n||d
<01>}<11>
qJW|<10>3<EFBFBD>
<00>
q|<10>3<EFBFBD>
wg|_||_4|<00>5<EFBFBD>
|j6<6A>
r<>|j7<6A>
r<>|j<08>8<EFBFBD>
d
|_|j<05>
s<>t2<74>
s<>|
dk<00>
r<>t9|
dd<19><02>
tj<03>|<00>
S)z"Load image data based on tile listNzcannot load this imagerr
<00>	load_readF<64>	load_seek<65>raw<61>zTile offset cannot be negative)
<01>accesszbuffer is not large enoughr<00>
<01>key<65>tile_prefix<69>c
S
sg|]
\}
}t|<02>
d<00>qS)
r
)
<01>list)rl<00>
_<>tilesr r r!rpo
s
<EFBFBD><06>z"ImageFile.load.<locals>.<listcomp>c

S
s|d
|d|dfS)Nr
rr<>r )
r=r r r!<00><lambda>r
sz ImageFile.load.<locals>.<lambda>Tzimage file is truncatedzimage file is truncated (z bytes not processed)<29>
r):r=<00>_imrr	r<><00>mapr4r<>r2<00>hasattrr<72>r<>r<>rrHr'rvrQ<00>	_MAPMODESrb<00>mmaprB<00>fileno<6E>ACCESS_READrRr<00>
map_bufferr<EFBFBD><00>palette<74>dirtyr<00>ImportError<6F>load_prepare<72>sortr&ra<00>	itertools<6C>groupby<62>	enumerate<74>_getdecoderr?<00>setimage<67>pulls_fd<66>setfd<66>decoderAr+rKrOr<00>LOAD_TRUNCATED_IMAGES<45>cleanupr><00>load_endrE<00>!_close_exclusive_fp_after_loadingrTr")rUr<00>pixel<65>use_mmapr>r<>r<00>decoder_namer*r+r,r<>r2<00>err_code<64>prefix<69>
ir<00>
b<>
read_bytes<EFBFBD>next_offset<65>
s<>
e<>
nr r r!r<>#
s<>















<02>





<1C> 



<06>
<04>


<02>



<02><08>


<04>
















<08><02>


<06><02>




<04><02>!



zImageFile.loadc

C
s<|jdurt
j<02>|j|j<05>|_|jd
krt
j
<01>|<00>

dSdS)N<>
P)r<>r	r<00>newrQrRr<>r<>r\r r r!r<><00>
s




<04>zImageFile.load_preparec


C
rZr[r r\r r r!r<><00>
<00>zImageFile.load_end<6E>framerrcC
sJ|
|jkst
|d
<01>r|jdus|
t|d<02>|jkrd}t|<02>
<01>
|<00><05>|
kS)N<>	_n_frames<65>n_framesz attempt to seek outside sequence)r;r<>r<>rarNr~)rUr<>rr r r!<00>_seek_check<63>
s
<02>


zImageFile._seek_checkr[)r2r3r4r5rr6<00>rr6)rr1<00>r,rdrr6)rrj)rr<>)rr<>)r<>r<>rr6<00>rr<>)r<>rrr)r-r.r/<00>__doc__r:rGr_rcrfrTr<>r<>r<>r<>r<>r<>r<>r<>r<><00>
__classcell__r r rXr!r1rs&
<10>
8




5

	

r1c@
s&eZ
dZddd<06>Zejddd	<09><04>
Zd
S)
<0A>StubHandlerr<72>rIrr6c
C
rZr[r <00>rUr<>r r r!rB<00>
r]zStubHandler.open<65>Image.Imagec
C
rZr[r r<>r r r!r<><00>
r<>zStubHandler.loadN)r<>rIrr6)r<>rIrr<>)r-r.r/rB<00>abc<62>abstractmethodr<64>r r r r!r<><00>
s


r<>c@
s:eZ
dZd
Zejd
dd<05><04>
Zddd<08>Zejdd
d<0B><04>
ZdS)rIz<>
    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.
    rr6c


C
rZr[r r\r r r!rG<00>
r<>zStubImageFile._openr<6E>c
C
sT|<00><00>}
|
durd
|j
<01>d<02>}t|<02>
<01>
|
<01>|<00>
}|du
sJ<00>
|j|_|j|_|<03><03>S)Nzcannot find loader for this z file)rJr<>rr<>rY<00>__dict__)rUrVr<00>imager r r!r<><00>
s








zStubImageFile.load<61>StubHandler | Nonec


C
<01>d
S)z (Hook) Find actual image loader.Nr r\r r r!rJ<00>
szStubImageFile._loadNr<4E>r<>)rr<>)	r-r.r/r<>r<>r<>rGr<>rJr r r r!rI<00>
s



rI)
<01>	metaclassc@
steZ
dZUd
ZdZdZded<dZded<dZded<d	Z	d	Z
ddd
<0A>Zddd<10>Zddd<12>Z
ddd<16>Zddd<19>ZdS)<1F>Parserzj
    Incremental image parser.  This class implements the standard
    feed/close consumer interface.
    NzImage.Image | Noner<65>zbytes | Noner<65>z,Image.core.ImagingDecoder | PyDecoder | Nonerr
rr6c

C
s|jd
us	Jd<02>
<01>
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.
        Nzcannot reuse parsers)
r<>r\r r r!<00>resetszParser.resetrFcC
s<>
|jrd
S|j
d
ur|
|_
n|j
|
|_
|jri|jdkr=tt|j
<01>
|j<03>}|j
|d
<01>|_
|j||_|jdks;|j
s=d
S|j<02>|j
<01>
\}}|dkr_d
|_
d|_|dkr]d
|_t|dd<05><02>
d
S|j
|d
<01>|_
d
S|jrnd
Szt	<09>
|j
<01>
<01>
}t<0B>|<05>
}Wd
<00>
n1s<>w



Y
Wn
t
y<>


Yd
Swt|d<06>p<>t|d<07>}|s<>t|j<0F>
dkr<>|<06><10>
|jd\}}}	}
g|_t<0B>|j||
|j<13>|_|j<02>|j|<04>
|	|_|jt|j
<01>
k
r<>|j
|jd
<01>|_
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
rFr<46>r<>r<>)<16>finishedr<64>rr+<00>minr<6E>r<>r<>r"r<>r<>r	rBrr<>r=r<>r<>rQr?r<>r<>)rUr<><00>skipr<70>r<>r2r<><00>flag<61>
d<>
o<>
ar r r!<00>feedsV	














<1C><04>
<02>








zParser.feedc


C
r^r[r r\r r r!r_\r]zParser.__enter__r,rdc
G
s|<00><00>
dSr[)
rTrer r r!rf_s
zParser.__exit__r<5F>c
	C
s<>|jr|<00>
d
<01>

d|_|_|jsd}
t|
<01>
<01>
|js d}
t|
<01>
<01>
|jrOt<06>|j<02>
<01>}z
t<08>	|<02>
|_W|j<05>
<EFBFBD>
n|j<05>
<EFBFBD>
wWd<00>
|jS1sJw



Y
|jS)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<>Nzimage was incompletezcannot parse this image)rr<>r<>r<>rr<>r<>r<>r	rBr<>)rUrr2r r r!rTbs$












<EFBFBD><10>zParser.closer<65>)r<>rFrr6)rr<>r<>)rr<>)r-r.r/r<><00>incrementalr<6C>r0r<>rr+r<>r<>r<>r_rfrTr r r r!r<><00>
s









I
r<>r<>r<>r2<00>	IO[bytes]r=<00>list[_Tile]<5D>bufsizer6c
C
s<>|<00><00>
t
|d
<01>sd|_|jtd<03>

tt||jdd<00>}z|
<01><08>}|
<01>	<09>
t
||
|||<04>
Wnttj
fyM
}
zt
||
||d|<05>
WYd}~nd}~w
wt
|
d<07>rY|
<01>	<09>
dSdS)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
    <20>
encoderconfigr r<>r
<00>N<>flush)r<>r<>r<>r<>r&<00>maxr@rRr<>r<><00>_encode_tilerr<><00>UnsupportedOperation)r<>r2r=r<><00>fh<66>excr r r!<00>_save<76>s 	









<08><02>

<04>r
r<><00>
int | Noner<65><00>BaseException | Nonec
	C
s<>|D]i\}}}}	|d
kr|
<01>|<08>

t
<01>|j||	|j<04>}
zK|
<EFBFBD>|j|<07>
|
jr2|
<EFBFBD>|
<01>

|
<EFBFBD>	<09>d}n$|rJ	|
<EFBFBD>
|<03>
dd<00>\}}|
<01>|<0C>

|rHn
q5n|du
sPJ<00>
|
<EFBFBD>||<03>}|d
krat
|dd<04>|<05>W|
<EFBFBD><0E>
q|
<EFBFBD><0E>
wdS)Nr
rTr<54>)rr	<00>_getencoderrQr<>r<>r<><00>	pushes_fdr<64><00>encode_to_pyfd<66>encode<64>write<74>encode_to_filer"r<>)
r<>r2r=r<>r<>r<><00>encoder_namer*r+r,r<00>errcoder<65>r r r!r<><00>s0














<02>


<02><04>r<EFBFBD>rRrFcC
s<>|
d
k
rdS|
tk
r|<00>
|
<01>
}t|<02>
|
krd}t|<03>
<01>
|Sg}|
}|d
kr?|<00>
t|t<00><02>
}|s0n|<04>|<06>

|t|<06>
8}|d
ks%tdd<05>|D<00>
<01>
|
krPd}t|<03>
<01>
d<02>|<04>
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<>zTruncated File Readc
s
s<00>|]}
t|
<01>
V
qdSr[)
r<>)rl<00>blockr r r!<00>	<genexpr><3E>s<02>z_safe_read.<locals>.<genexpr>)<08>	SAFEBLOCKr<4B>r<>rr<>r|<00>sum<75>join)r2rRr<>r<00>blocks<6B>remaining_sizer
r r r!<00>
_safe_read<EFBFBD>s*

















<08>



r
c@
s eZ
dZd	dd<04>Zd
dd<07>ZdS)<0B>PyCodecStaterr6c

C
sd
|_d
|_
d
|_d
|_dS)Nr
)<04>xsize<7A>ysize<7A>xoff<66>yoffr\r r r!r:<00>s




zPyCodecState.__init__<5F>tuple[int, int, int, int]c

C
s |j|j
|j|j|j
|jfSr[)r
r
r
r
r\r r r!r*<00>s 
zPyCodecState.extentsNr<4E>)rr
)r-r.r/r:r*r r r r!r
<00>s

r
c@
sLeZ
dZUd
ed<dd	d
<EFBFBD>Zddd
<0A>Zddd<0F>Zddd<12>Z	dddd<19>ZdS) <20>PyCodeczIO[bytes] | None<6E>fdrQr'r,rrr6cG
s(d|_t
<01>|_d|_|
|_|<00>|<02>

dSr[)r<>r
r<>r
rQ<00>init)rUrQr,r r r!r:<00>s





zPyCodec.__init__<5F>tuple[Any, ...]cC
<01>
|
|_d
S)z<>
        Override to perform codec specific initialization

        :param args: Tuple of arg items from the tile entry
        :returns: None
        N)
r,rer r r!r
<00><00>
zPyCodec.initc


C
r<>)zT
        Override to perform codec specific cleanup

        :returns: None
        Nr r\r r r!r<>szPyCodec.cleanupr<70>cC
r
)z<>
        Called from ImageFile to set the Python file-like object

        :param fd: A Python file-like object
        :returns: None
        N)
r
)rUr
r r r!r<>r
z
PyCodec.setfdNr<4E><00>Image.core.ImagingCorer*r)cC
s<>|
|_|r>|\}}}}|d
ks#|d
ks#||jj
d
ks#||jj
dkr)d}t|<07>
<01>
||j_||j_|||j_|||j_n
|jj
\|j_|j_|jjd
k
sT|jjd
k
rZd}t|<07>
<01>
dS)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
rz Tile cannot extend outside imagezSize must be positiveN)r<>rRrbr<>r
r
r
r
)rUr<>r*<00>x0<78>y0<79>x1<78>y1rr r r!r<>s
0






<04>zPyCodec.setimage)rQr'r,rrr6)r,r
rr6r<>)r
r<>rr6r[)r<>r
r*r)rr6)	r-r.r/r0r:r
r<>r<>r<>r r r r!r
<00>s




	
<10>r
c@
s:eZ
dZd
ZdZeddd<06><04>
Zdd
d<0B>Z	
dddd<16>ZdS)<1B>	PyDecoderz<72>
    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>`
    Frrc


C
<01>|jSr[)
<01>	_pulls_fdr\r r r!r<>C<00>zPyDecoder.pulls_fd<66>buffer<65>$bytes | Image.SupportsArrayInterface<63>tuple[int, int]cC
<01>d
}t|<02>
<01>
)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`.
        zunavailable in base decoder<65>
<01>NotImplementedError)rUr(
rr r r!r<>G<00>	
zPyDecoder.decodeNr r<>rF<00>rawmoder<65><00>extrar
r6cC
s||s|j}t
<01>|jd
||<03>}|jdu
sJ<00>
|<04>|j|j<05><06><00>
|<04>|
<01>
}|ddkr0d}t|<06>
<01>
|ddkr<d}t|<06>
<01>
dS)aS

        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
        :param extra: Extra arguments for the decoder.
        :returns: None
        r<>Nr
znot enough image datarzcannot decode image data)	rQr	r<>r<>r<>r<>r*r<>rb)rUr<>r/
r0
r<>r<>rr r r!<00>
set_as_rawSs











<04>zPyDecoder.set_as_raw<61>rr)r(
r)
rr*
)Nr )r<>rFr/
r<>r0
r
rr6)	r-r.r/r<>r&
<00>propertyr<79>r<>r1
r r r r!r$
9s



<10>r$
c@
s@eZ
dZd
ZdZeddd<06><04>
Zdd
d<0B>Zdd
d<0E>Zddd<11>Z	dS)<17>	PyEncoderz<72>
    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>`
    Frrc


C
r%
r[)
<01>
_pushes_fdr\r r r!r
yr'
zPyEncoder.pushes_fdr<64>r<00>tuple[int, int, bytes]cC
r+
)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`.
        zunavailable in base encoderr,
)rUr<>rr r r!r
}r.
zPyEncoder.encoder*
c
C
s@|jsd
S|<00>
d<02>
\}
}}|r|jdu
sJ<00>
|j<02>|<03>

|
|fS)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
rr
N)r
r
r
r
)rU<00>bytes_consumedr

r<>r r r!r
<00>s





zPyEncoder.encode_to_pyfdr<64>cC
sDd
}|d
kr |<00>|<02>
\}}}|d
krt
<01>|
||d<02><00>
|d
ks|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
rCr
)rUr<>r<>r

<00>status<75>bufr r r!r
<00>s	



<08>zPyEncoder.encode_to_fileNr2
)r<>rrr6
)rr*
)r<>rr<>rrr)
r-r.r/r<>r5
r3
r
r
r
r
r r r r!r4
os



r4
)rrrrrr)r#r$rr)
r
)
r<EFBFBD>r<>r2r<>r=r<>r<>rrr6r[)r<>r<>r2r<>r=r<>r<>rr<>r

r<>r
rr6)r2r<>rRrrrF)-<2D>
__future__rr<>r<>r<><00>loggingrCrO<00>typingrrrrr8rr	<00>_utilr
r<00>
TYPE_CHECKING<4E>_typingr<00>	getLoggerr-rhr@r

r<>rr"r&r$r1<00>ABCr<43><00>ABCMetarIr<>r
r<>r
r
r
r$
r4
r r r r!<00><module>
sX
















<06>

g	"<0C>
##H6