U e5d��� @shdZddlmZddlmZddlmZmZmZddlm Z ddl m Z ddl Z ddl m Z dd lmZmZddlZddlZddlZddlZd d d d dddddg ZzddlmZe�d�dZWnek r�dZYnXeefZdZddddddddgZdZ d Z!Gd!d �d e"�Z#Gd"d �d e#�Z$Gd#d �d e#�Z%Gd$d%�d%e"�Z&zdd&l'm(Z(Wnek �rldZ(YnXd'Z)d(Z*d)Z+d*Z,d+Z-d,Z.d-Z/d.Z0d/Z1d0Z2d1Z3d2Z4d3Z5d4Z6d5Z7d6Z8d7Z9d8Z:d9Z;d:Zd=Z?d>Z@d?ZAd@ZBdAZCdBZDdCZEdDZFdEZGdFZHdGZIdHZJdIZKdJZLdKZMdLZNdMZOdNZPdOZQdPZRdQZSdRZTdSZUdTZVdUZWdVZXdWZYdXZZdYZ[dZZ\d[Z]d\Z^d]Z_eOeYeZe[gZ`d^Zad_Zbd`ZcdaZddbZedcZfddZgdeZhdfZidgZjdhZkdiZldjZmdkZndlZoe�pdmdn�eq�D��Gdodp�dp�ZrGdqdr�dr�Zsdsdt�Ztdudv�Zudwdx�Zvdydz�ZwGd{d|�d|�ZxGd}d~�d~�Zyd�ddd�d�d��Zzd�ddd�d�d��Z{dd�d�dd��d�d��Z|dd�d�dd��d�d��Z}z0dd�lm#Z#m$Z$m%Z%m~Z~mZm�Z�m�Z�m�Z�m�Z�Wn4ek �r�exeyZ~Zeze{e|e}f\Z�Z�Z�Z�YnXd�d��Z�e�d�k�rdddl�Z�e�j�d�d��Z�e�j�d�e���d��d�d�d��e�j�d�d�d�d�d��e�j�d�d�d�d��e����Z�e�j��r*e��n:e�j��s string load(file) -> object loads(string) -> object Misc variables: __version__ format_version compatible_formats �)� FunctionType)�dispatch_table)�_extension_registry�_inverted_registry�_extension_cache)�islice)�partialN)�maxsize)�pack�unpack� PickleError� PicklingError�UnpicklingError�Pickler� Unpickler�dump�dumps�load�loads)� PickleBufferrTFz4.0z1.0z1.1z1.2z1.3z2.0z3.0z5.0��c@seZdZdZdS)r z6A common base class for the other pickling exceptions.N��__name__� __module__� __qualname__�__doc__�rr�/usr/lib64/python3.8/pickle.pyr Isc@seZdZdZdS)r z]This exception is raised when an unpicklable object is passed to the dump() method. Nrrrrrr Msc@seZdZdZdS)raThis exception is raised when there is a problem unpickling an object, such as a security violation. Note that other exceptions may also be raised during unpickling, including (but not necessarily limited to) AttributeError, EOFError, ImportError, and IndexError. NrrrrrrTsc@seZdZdd�ZdS)�_StopcCs ||_dS�N)�value��selfr!rrr�__init__bsz_Stop.__init__N)rrrr$rrrrrasr)� PyStringMap�(�.�0�1�2�F�I�J�K�L�M�N�P�Q�R�S�T�U�V�X�a�b�c�d�}�e�g�h�i�j�l�]�o�p�q�r�s�t�)�u�GsI01 sI00 �������������������������B�C��������������������������cCsg|]}t�d|�r|�qS)z[A-Z][A-Z0-9_]+$)�re�match)�.0�xrrr� �s rnc@sFeZdZdZdZdd�Zdd�Zdd�Zdd d �Zd d �Z dd�Z dS)�_FramerricCs||_d|_dSr )� file_write� current_frame)r#rprrrr$�sz_Framer.__init__cCst��|_dSr )�io�BytesIOrq�r#rrr� start_framing�sz_Framer.start_framingcCs*|jr&|j��dkr&|jdd�d|_dS)NrT��force)rq�tell� commit_framertrrr� end_framing�s z_Framer.end_framingFcCsf|jrb|j}|��|jks|rb|��}|j}t|�|jkrP|ttdt|���||�t � �|_dS)N�z&Can't get local attribute {!r} on {!r}z Can't get attribute {!r} on {!r})�split�AttributeError�format�getattr)�obj�nameZsubpath�parentrrr� _getattributeBs"��� r�c Cs�t|dd�}|dk r|Stj����D]X\}}|dks&|dks&|dkrHq&z t||�d|krf|WSWq&tk r|Yq&Xq&dS)z$Find the module an object belong to.rN�__main__Z __mp_main__r)r��sys�modules�copy�itemsr�r�)r�r�� module_name�modulerrr� whichmoduleOs  ��r�cCsh|dkr dS|��d?d}|j|ddd�}|dkrd|dkrd|dd krd|d d @dkrd|d d�}|S) a�Encode a long to a two's complement little-endian binary string. Note that 0 is a special case, returning an empty string, to save a byte in the LONG1 pickling context. >>> encode_long(0) b'' >>> encode_long(255) b'\xff\x00' >>> encode_long(32767) b'\xff\x7f' >>> encode_long(-256) b'\x00\xff' >>> encode_long(-32768) b'\x00\x80' >>> encode_long(-128) b'\x80' >>> encode_long(127) b'\x7f' >>> rr����littleT�� byteorderZsignedr���������N)� bit_length�to_bytes)rm�nbytes�resultrrr� encode_longbs r�cCstj|ddd�S)a\Decode a long from a two's complement little-endian binary string. >>> decode_long(b'') 0 >>> decode_long(b"\xff\x00") 255 >>> decode_long(b"\xff\x7f") 32767 >>> decode_long(b"\x00\xff") -256 >>> decode_long(b"\x00\x80") -32768 >>> decode_long(b"\x80") -128 >>> decode_long(b"\x7f") 127 r�Tr�)�int� from_bytes)r�rrr� decode_long�sr�c@s�eZdZd;ddd�dd�Zdd�Zdd �Zd d �Zd d �Zdd�Zdd7d8�Z-d9d:�Z.e-e e/<e.e e<dS)?�_PicklerNT�� fix_imports�buffer_callbackcCs�|dkr t}|dkrt}n"d|kr.tks= 5z"file must have a 'write' attributer�r�)�DEFAULT_PROTOCOL�HIGHEST_PROTOCOL� ValueError�_buffer_callbackr�� _file_writer�� TypeErrorro�framerr��_write_large_bytes�memor��proto�bin�fastr�)r#�file�protocolr�r�rrrr$�s*#       z_Pickler.__init__cCs|j��dS)aClears the pickler's "memo". The memo is the data structure that remembers which objects the pickler has already seen, so that shared or recursive objects are pickled by reference and not by value. This method is useful when re-using picklers. N)r��clearrtrrr� clear_memo�sz_Pickler.clear_memocCsrt|d�std|jjf��|jdkr<|�ttd|j��|jdkrP|j� �|� |�|�t �|j� �dS)z7Write a pickled representation of obj to the open file.r�z2Pickler.__init__() was not called by %s.__init__()��z |�tt|��d�d�Wntk r\td��YnXdS)NF)r�r�r��2persistent IDs in protocol 0 must be ASCII strings) r�r�r�� BINPERSID�PERSIDr�r��UnicodeEncodeErrorr �r#r�rrrr�as  �z_Pickler.save_persc Cs>t|t�std��t|�s"td��|j}|j} t|dd�} |jdkr�| dkr�|\} }} t| d�sntd� | ���|dk r�| |j k r�td � | ���|jd kr�|| �||�|| �| t �n,t | j | f|�| �}||�|d �| t�n�|jdk�r^| d k�r^|d } t| d��std��|dk �r8| |j k �r8td��|dd�}|| �||�| t�n||�||�| t�|dk �r�t|�|jk�r�| t|�|jt|�d ��n |�|�|dk �r�|�|�|dk �r�|�|�|dk �r:|dk�r ||�| t�n0||�||�||�| t�| t�| t�dS)Nz'args from save_reduce() must be a tuplez(func from save_reduce() must be callabler�r�� __newobj_ex__�__new__z#args[0] from {} args has no __new__z(args[0] from {} args has the wrong classrr� __newobj__rz+args[0] from __newobj__ args has no __new__z0args[0] from __newobj__ args has the wrong classr�)r�r�r �callabler�r�r�r�r�r�r�� NEWOBJ_EXrr�REDUCE�NEWOBJr�r��POPr�r��_batch_appends�_batch_setitems�BUILD�TUPLE2) r#�func�args�stateZ listitemsZ dictitemsZ state_setterr�r�r�Z func_name�cls�kwargsrrrr�msz    ��    ��   "        z_Pickler.save_reducecCs|�t�dSr )r��NONEr�rrr� save_none�sz_Pickler.save_nonecCs4|jdkr|�|rtnt�n|�|r*tnt�dS)Nr�)r�r��NEWTRUE�NEWFALSE�TRUE�FALSEr�rrr� save_bool�s z_Pickler.save_boolcCs.|jr~|dkrN|dkr.|�ttd|��dS|dkrN|�ttd|��dSd|krbdkr~nn|�ttd|��dS|jd kr�t|�}t|�}|d kr�|�t td|�|�n|�t td|�|�dSd|kr�dk�rnn|�t t |�� d �d �n|�tt |�� d �d �dS)Nrr�r�����dr�r�)r�r��BINFLOATr �FLOATr�r�r�rrr� save_floatsz_Pickler.save_floatcCs�|jdkr@|s |jtd|d�n|jtjt|d�df|d�dSt|�}|dkrj|�tt d|�|�nf|dkr�|jdkr�|� t t d |�|�n<||j j kr�|� tt d |�|�n|�tt d |�|�|�|�dS) Nr�r�r��latin1r�r����rr{r�)r�r��bytes�codecsr�r�r~r��SHORT_BINBYTESr r�� BINBYTES8r�r|�BINBYTESr��r#r�r�rrr� save_bytess"  � z_Pickler.save_bytescCs�|jdkr:|s |jtd|d�n|jtt|�f|d�dSt|�}||jjkrf|�tt d|�|�n|� tt d|�|�dS)Nrrr+r{) r�r�� bytearrayr.r~r�r|r�� BYTEARRAY8r r�r3rrr�save_bytearray)s  z_Pickler.save_bytearrayc Cs�|jdkrtd��|���t}|js*td��d}|jdk rFt|�|��}|rp|jr`|�|���q�|� |���n|� t �|jr�|� t �W5QRXdS)Nrz0PickleBuffer can only pickled with protocol >= 5zHPickleBuffer can not be pickled when pointing to a non-contiguous bufferT) r�r �raw� contiguousr��bool�readonlyr4�tobytesr7r�� NEXT_BUFFER�READONLY_BUFFER)r#r��mZin_bandrrr�save_picklebuffer8s    z_Pickler.save_picklebuffercCs|jr�|�dd�}t|�}|dkrF|jdkrF|�ttd|�|�nf|dkrp|jdkrp|�ttd|�|�n<||j j kr�|�t td|�|�n|�t td|�|�nT|� d d �}|� d d �}|� d d�}|� dd�}|� dd�}|�t |�d�d�|�|�dS)N�utf-8� surrogatepassr�rr�r-r{r��\z\u005c�z\u0000� z\u000a� z\u000d�z\u001a�raw-unicode-escaper�)r�r�r~r�r��SHORT_BINUNICODEr r�� BINUNICODE8r�r|� BINUNICODE�replace�UNICODEr�r%rrr�save_strRs&       �z_Pickler.save_strcCs:|s(|jr|�t�n|�tt�dSt|�}|j}|j}|dkr�|jdkr�|D] }||�qRt |�|kr�|� |t |�d�}|�t ||�n|�t |�|� |�dS|j}|t�|D] }||�q�t |�|k�r$|� |t |�d�}|j�r |t|�n|t |d|�dS|t�|� |�dS)Nr�r�rr�)r�r�� EMPTY_TUPLE�MARK�TUPLEr~r�r�r�r�r�r �_tuplesize2coder��POP_MARK)r#r�r�r�r�Zelementr�r�rrr� save_tupleis:     z_Pickler.save_tuplecCs8|jr|�t�n|�tt�|�|�|�|�dSr )r�r�� EMPTY_LISTrP�LISTr�r r�rrr� save_list�s   z_Pickler.save_listi�cCs�|j}|j}|js0|D]}||�|t�qdSt|�}tt||j��}t|�}|dkr||t �|D] }||�qd|t �n|r�||d�|t�||jkr8dSq8dS�Nr�r) r�r�r��APPEND�iter�listr� _BATCHSIZEr~rP�APPENDS)r#r�r�r�rm�it�tmpr�rrrr �s(     z_Pickler._batch_appendscCs<|jr|�t�n|�tt�|�|�|�|���dSr )r�r�� EMPTY_DICTrP�DICTr�r r�r�rrr� save_dict�s   z_Pickler.save_dictc Cs�|j}|j}|js<|D] \}}||�||�|t�qdSt|�}tt||j��}t|�}|dkr�|t �|D]\}}||�||�qp|t �n(|r�|d\}}||�||�|t�||jkrDdSqDdSrX) r�r�r��SETITEMrZr[rr\r~rP�SETITEMS) r#r�r�r��k�vr^r_r�rrrr �s0       z_Pickler._batch_setitemscCs�|j}|j}|jdkr0|jtt|�f|d�dS|t�|�|�t|�}tt ||j ��}t |�}|dkr�|t �|D] }||�qv|t �||j krJdSqJdS�Nrr+r)r�r�r�r��setr[� EMPTY_SETr�rZrr\r~rP�ADDITEMS)r#r�r�r�r^Zbatchr��itemrrr�save_set�s"    z_Pickler.save_setcCs�|j}|j}|jdkr0|jtt|�f|d�dS|t�|D] }||�q�Z5e5ee6d<d?d@�Z7e7ee8d<dAdB�Z9e9ee:d<dCdD�Z;e;eed<dGdH�Z?e?ee@d<dIdJ�ZAeAeeBd<dKdL�ZCeCeeDd<dMdN�ZEeEeeFd<dOdP�ZGeGeeHd<dQdR�ZIeIeeJd<dSdT�ZKeKeeLd<dUdV�ZMeMeeNd<dWdX�ZOeOeePd<dYdZ�ZQeQeeRd<d[d\�ZSeSeeTd<d]d^�ZUeUeeVd<d_d`�ZWeWeeXd<dadb�ZYdcdd�ZZeZee[d<dedf�Z\e\ee]d<dgdh�Z^e^ee_d<didj�Z`e`eead<dkdl�Zbebeecd<dmdn�Zdedeeed<dodp�Zfefeegd<dqdr�Zheheeid<dsdt�Zjejeekd<dudv�Zldwdx�Zmdydz�Zneneeod<d{d|�Zpepeeqd<d}d~�Zrereesd<dd��Zteteeud<d�d��Zveveewd<d�d��Zxexeeyd<d�d��Zzezee{d<d�d��Z|e|ee}d<d�d��Z~e~eed<d�d��Z�e�ee�d<d�d��Z�e�ee�d<d�d��Z�e�ee�d<d�d��Z�e�ee�d<d�d��Z�e�ee�d<d�d��Z�e�ee�d<d�d��Z�e�ee�d<d�d��Z�e�ee�d<d�d��Z�e�ee�d<d�d��Z�e�ee�d<dS)�� _UnpicklerT�ASCII�strictN�r��encoding�errors�bufferscCsH|dk rt|�nd|_|j|_|j|_i|_||_||_d|_ ||_ dS)a�This takes a binary file for reading a pickle data stream. The protocol version of the pickle is detected automatically, so no proto argument is needed. The argument *file* must have two methods, a read() method that takes an integer argument, and a readline() method that requires no arguments. Both methods should return bytes. Thus *file* can be a binary file object opened for reading, an io.BytesIO object, or any other custom object that meets this interface. The file-like object must have two methods, a read() method that takes an integer argument, and a readline() method that requires no arguments. Both methods should return bytes. Thus file-like object can be a binary file object opened for reading, a BytesIO object, or any other custom object that meets this interface. If *buffers* is not None, it should be an iterable of buffer-enabled objects that is consumed each time the pickle stream references an out-of-band buffer view. Such buffers have been given in order to the *buffer_callback* of a Pickler object. If *buffers* is None (the default), then the buffers are taken from the pickle stream, assuming they are serialized there. It is an error for *buffers* to be None if the pickle stream was produced with a non-None *buffer_callback*. Other optional arguments are *fix_imports*, *encoding* and *errors*, which are used to control compatibility support for pickle stream generated by Python 2. If *fix_imports* is True, pickle will try to map the old Python 2 names to the new names used in Python 3. The *encoding* and *errors* tell pickle how to decode 8-bit string instances pickled by Python 2; these default to 'ASCII' and 'strict', respectively. *encoding* can be 'bytes' to read theses 8-bit string instances as bytes objects. Nr) rZ�_buffersr��_file_readliner�� _file_readr�r�r�r�r�)r#r�r�r�r�r�rrrr$rs'z_Unpickler.__init__c Cs�t|d�std|jjf��t|j|j�|_|jj|_|jj |_ |jj |_ g|_ g|_ |j j |_ d|_|j}|j}z4|d�}|s�t�t|t�s�t�||d|�qtWn,tk r�}z|jWY�Sd}~XYnXdS)z�Read a pickled object representation from the open file. Return the reconstituted object hierarchy specified in the file. r�z4Unpickler.__init__() was not called by %s.__init__()rr�N)r�rr�rr�r�r�� _unframerr�r�r�� metastack�stack�appendr�r��EOFErrorr�� bytes_typesr�rr!)r#r�r��keyZstopinstrrrr�s, �    z_Unpickler.loadcCs |j}|j��|_|jj|_|Sr )r�r��popr��r#r�rrr�pop_mark�s  z_Unpickler.pop_markcCs td��dS)Nz%unsupported persistent id encountered)rrrrr�persistent_load�sz_Unpickler.persistent_loadcCs:|�d�d}d|kr"tks0ntd|��||_dS)Nr�rzunsupported pickle protocol: %d)r�r�r�r�)r#r�rrr� load_proto�s z_Unpickler.load_protorcCs8td|�d��\}|tjkr(td|��|j�|�dS)Nr{�zframe size > sys.maxsize: %d)r r�r�r r�r�r�r�rrrr��s  z_Unpickler.load_framecCsLz|��dd��d�}Wntk r6td��YnX|�|�|��dS)Nr�r�r�)r��decode�UnicodeDecodeErrorrr�r�rrrr� load_persid�s� z_Unpickler.load_persidcCs|j��}|�|�|��dSr )r�r�r�r�rrrr�load_binpersid�s z_Unpickler.load_binpersidcCs|�d�dSr �r�rtrrr� load_none�sz_Unpickler.load_nonecCs|�d�dS)NFr�rtrrr� load_false�sz_Unpickler.load_falsecCs|�d�dS)NTr�rtrrr� load_true�sz_Unpickler.load_truecCsL|��}|tdd�krd}n |tdd�kr4d}n t|d�}|�|�dS)Nr�FTr)r�rrr�r�)r#r��valrrr�load_int�s z_Unpickler.load_intcCs|�td|�d��d�dS)Nrrr�r�r r�rtrrr� load_binint�sz_Unpickler.load_binintcCs|�|�d�d�dSrX)r�r�rtrrr� load_binint1sz_Unpickler.load_binint1cCs|�td|�d��d�dS)Nrr�rr�rtrrr� load_binint2sz_Unpickler.load_binint2cCs@|��dd�}|r,|ddkr,|dd�}|�t|d��dS)Nr��Lr)r�r�r�)r#r�rrr� load_long s z_Unpickler.load_longcCs*|�d�d}|�|�}|�t|��dSrX)r�r�r�r�rrr� load_long1s z_Unpickler.load_long1cCs>td|�d��\}|dkr"td��|�|�}|�t|��dS)Nrrrz#LONG pickle has negative byte count)r r�rr�r�r�rrr� load_long4s  z_Unpickler.load_long4cCs|�t|��dd���dS�Nr�)r�r~r�rtrrr� load_float!sz_Unpickler.load_floatcCs|�td|�d��d�dS)Nr'r�rr�rtrrr� load_binfloat%sz_Unpickler.load_binfloatcCs"|jdkr|S|�|j|j�SdS)Nr.)r�r�r�r"rrr�_decode_string)s z_Unpickler._decode_stringcCsl|��dd�}t|�dkrF|d|dkrF|ddkrF|dd�}ntd��|�|�t�|�d��dS)Nr�r�rs"'r�z)the STRING opcode argument must be quoted)r�r~rr�r�r/� escape_decoder�rrr� load_string2s (z_Unpickler.load_stringcCs@td|�d��\}|dkr"td��|�|�}|�|�|��dS)Nrrrz(BINSTRING pickle has negative byte count)r r�rr�r��r#r~r�rrr�load_binstring<s  z_Unpickler.load_binstringcCs:td|�d��\}|tkr&tdt��|�|�|��dS)Nr�rz2BINBYTES exceeds system's maximum size of %d bytes�r r�r rr��r#r~rrr� load_binbytesEs �z_Unpickler.load_binbytescCs |�t|��dd�d��dS)Nr�rH)r�r�r�rtrrr� load_unicodeMsz_Unpickler.load_unicodecCsBtd|�d��\}|tkr&tdt��|�t|�|�dd��dS)Nr�rz4BINUNICODE exceeds system's maximum size of %d bytesrArB�r r�r rr�r�r�rrr�load_binunicodeQs �z_Unpickler.load_binunicodecCsBtd|�d��\}|tkr&tdt��|�t|�|�dd��dS)Nr{r�z5BINUNICODE8 exceeds system's maximum size of %d bytesrArBr�r�rrr�load_binunicode8Ys �z_Unpickler.load_binunicode8cCs:td|�d��\}|tkr&tdt��|�|�|��dS)Nr{r�z3BINBYTES8 exceeds system's maximum size of %d bytesr�r�rrr�load_binbytes8as �z_Unpickler.load_binbytes8cCsFtd|�d��\}|tkr&tdt��t|�}|�|�|�|�dS)Nr{r�z4BYTEARRAY8 exceeds system's maximum size of %d bytes)r r�r rr5r�r�)r#r~�brrr�load_bytearray8is� z_Unpickler.load_bytearray8cCsL|jdkrtd��zt|j�}Wntk r<td��YnX|�|�dS)NzLpickle stream refers to out-of-band data but no *buffers* argument was givenznot enough out-of-band buffers)r�r�next� StopIterationr�)r#r�rrr�load_next_bufferss z_Unpickler.load_next_bufferc Cs6|jd}t|��}|js(|��|jd<W5QRXdSr�)r�� memoryviewr;� toreadonly)r#r�r?rrr�load_readonly_buffer~s  z_Unpickler.load_readonly_buffercCs,|�d�d}|�|�}|�|�|��dSrX)r�r�r�r�rrr�load_short_binstring�s z_Unpickler.load_short_binstringcCs"|�d�d}|�|�|��dSrX)r�r�r�rrr�load_short_binbytes�sz_Unpickler.load_short_binbytescCs*|�d�d}|�t|�|�dd��dS)Nr�rrArB)r�r�r�r�rrr�load_short_binunicode�sz _Unpickler.load_short_binunicodecCs|��}|�t|��dSr )r�r�r�r�rrr� load_tuple�sz_Unpickler.load_tuplecCs|�d�dS)Nrr�rtrrr�load_empty_tuple�sz_Unpickler.load_empty_tuplecCs|jdf|jd<dSr��r�rtrrr� load_tuple1�sz_Unpickler.load_tuple1cCs$|jd|jdfg|jdd�<dS)Nr�r�r�rtrrr� load_tuple2�sz_Unpickler.load_tuple2cCs,|jd|jd|jdfg|jdd�<dS)N�����r�r�r�rtrrr� load_tuple3�sz_Unpickler.load_tuple3cCs|�g�dSr r�rtrrr�load_empty_list�sz_Unpickler.load_empty_listcCs|�i�dSr r�rtrrr�load_empty_dictionary�sz _Unpickler.load_empty_dictionarycCs|�t��dSr )r�rhrtrrr�load_empty_set�sz_Unpickler.load_empty_setcCs|��}|�t|��dSr )r�r�rmr�rrr�load_frozenset�sz_Unpickler.load_frozensetcCs|��}|�|�dSr )r�r�r�rrr� load_list�sz_Unpickler.load_listcs4|����fdd�tdt��d�D�}|�|�dS)Ncsi|]}�|�|d�qS)r�r)rlr��r�rr� �s�z(_Unpickler.load_dict..rr�)r��ranger~r�)r#�drr�r� load_dict�s  �z_Unpickler.load_dictc Cs�|st|t�rt|d�rjz ||�}Wqttk rf}z$td|jt|�ft��d��W5d}~XYqtXn |�|�}|� |�dS)NZ__getinitargs__zin constructor for %s: %sr�) r�r�r�r�rr�r��exc_inforr�)r#�klassrr!�errrrr� _instantiate�s�  � � z_Unpickler._instantiatecCsL|��dd��d�}|��dd��d�}|�||�}|�||���dS)Nr�r�)r�r�� find_classr�r��r#r�r�r�rrr� load_inst�s z_Unpickler.load_instcCs"|��}|�d�}|�||�dS�Nr)r�r�r�)r#rrrrr�load_obj�s z_Unpickler.load_objcCs2|j��}|j��}|j|f|��}|�|�dSr �r�r�rr�)r#rrr�rrr� load_newobj�s  z_Unpickler.load_newobjcCs>|j��}|j��}|j��}|j|f|�|�}|�|�dSr r�)r#rrrr�rrr�load_newobj_ex�s    z_Unpickler.load_newobj_excCsF|��dd��d�}|��dd��d�}|�||�}|�|�dS)Nr�rA)r�r�r�r�r�rrr� load_global�s z_Unpickler.load_globalcCsJ|j��}|j��}t|�tk s,t|�tk r4td��|�|�||��dS)NzSTACK_GLOBAL requires str)r�r�r�r�rr�r�)r#r�r�rrr�load_stack_global�s   z_Unpickler.load_stack_globalcCs|�d�d}|�|�dSrX)r�� get_extension�r#r|rrr� load_ext1sz_Unpickler.load_ext1cCs td|�d��\}|�|�dS)Nrr��r r�r�r�rrr� load_ext2 sz_Unpickler.load_ext2cCs td|�d��\}|�|�dS)Nrrr�r�rrr� load_ext4sz_Unpickler.load_ext4cCspg}t�||�}||k r&|�|�dSt�|�}|sP|dkrDtd��td|��|j|�}|t|<|�|�dS)NrzEXT specifies code <= 0zunregistered extension code %d)rr�r�rrr�r�)r#r|Znilr�r�rrrr�s     z_Unpickler.get_extensioncCs�t�d||�|jdkrT|jrT||ftjkr@tj||f\}}n|tjkrTtj|}t|dd�|jdkr~ttj ||�dSt tj ||�SdS)Nzpickle.find_classr�rrpr) r��auditr�r�r{Z NAME_MAPPINGZIMPORT_MAPPINGrrr�r�r�)r#r�r�rrrr�#s    z_Unpickler.find_classcCs&|j}|��}|d}||�|d<dSr��r�r�)r#r�rrrrr� load_reduce1sz_Unpickler.load_reducecCs|jr|jd=n|��dSr�)r�r�rtrrr�load_pop8s z_Unpickler.load_popcCs |��dSr )r�rtrrr� load_pop_mark?sz_Unpickler.load_pop_markcCs|�|jd�dSr�)r�r�rtrrr�load_dupCsz_Unpickler.load_dupcCs(t|��dd��}|�|j|�dSr�)r�r�r�r�r�rrr�load_getGsz_Unpickler.load_getcCs"|�d�d}|�|j|�dSrX)r�r�r�r�rrr� load_bingetLsz_Unpickler.load_bingetcCs&td|�d��\}|�|j|�dS)Nr�r)r r�r�r�r�rrr�load_long_bingetQsz_Unpickler.load_long_bingetcCs8t|��dd��}|dkr$td��|jd|j|<dS)Nr�rznegative PUT argument)r�r�r�r�r�r�rrr�load_putVsz_Unpickler.load_putcCs2|�d�d}|dkrtd��|jd|j|<dS)Nr�rznegative BINPUT argumentr�)r�r�r�r�r�rrr� load_binput]sz_Unpickler.load_binputcCs6td|�d��\}|tkr"td��|jd|j|<dS)Nr�rznegative LONG_BINPUT argumentr�)r r�r r�r�r�r�rrr�load_long_binputdsz_Unpickler.load_long_binputcCs|j}|jd|t|�<dSr�)r�r�r~)r#r�rrr� load_memoizeksz_Unpickler.load_memoizecCs$|j}|��}|d}|�|�dSr�)r�r�r�)r#r�r!r[rrr� load_appendpsz_Unpickler.load_appendcCsZ|��}|jd}z |j}Wntk r0YnX||�dS|j}|D] }||�qHdSr�)r�r��extendr�r�)r#r�Zlist_objr�r�rkrrr� load_appendsws  z_Unpickler.load_appendscCs*|j}|��}|��}|d}|||<dSr�r�)r#r�r!r�r�rrr� load_setitem�s z_Unpickler.load_setitemcCs@|��}|jd}tdt|�d�D]}||d|||<q"dS)Nr�rr�r�)r�r�r�r~)r#r�r�r�rrr� load_setitems�s z_Unpickler.load_setitemscCsD|��}|jd}t|t�r(|�|�n|j}|D] }||�q2dSr�)r�r�r�rh�update�add)r#r�Zset_objr�rkrrr� load_additems�s   z_Unpickler.load_additemsc Cs�|j}|��}|d}t|dd�}|dk r6||�dSd}t|t�rXt|�dkrX|\}}|r�|j}tj}|� �D]*\}} t |�t kr�| |||�<qp| ||<qp|r�|� �D]\}} t ||| �q�dS)Nr�� __setstate__r�) r�r�r�r�r�r~�__dict__r��internr�r�r��setattr) r#r�r�inst�setstateZ slotstateZ inst_dictrrerfrrr� load_build�s(   z_Unpickler.load_buildcCs"|j�|j�g|_|jj|_dSr )r�r�r�rtrrr� load_mark�sz_Unpickler.load_markcCs|j��}t|��dSr )r�r�rr"rrr� load_stop�s z_Unpickler.load_stop)�rrrr$rr�r�r�r�r�r�r�r�r�r�r�r�rr�rr�rr�r#r�r r�rr�rr�r$r�r!r�r"r�r)r�r(r�r��STRINGr�� BINSTRINGr�r2r�rMr�rKr�rJr�r1r�r6r�r=r�r>r��SHORT_BINSTRINGr�r0r�rIr�rQr�rOr��TUPLE1r�rr��TUPLE3r�rUr�r`r�rir�rnr�rVr�rar�r��INSTr��OBJr�r r�rr�rzr�ryr�rur�rvr�rwr�r�r�rr�r r�rSr��DUPr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rYr�r]r�rcr�rdr�rjrr rrPrr�rrrrr�ps*� 0                                                                     r�r�cCst||||d��|�dS�Nr�)r�r)r�r�r�r�r�rrr�_dump�s ��rcCs8t��}t||||d��|�|��}t|t�s4t�|Sr)rrrsr�r�getvaluer�r�r�)r�r�r�r�r��resrrr�_dumps�s��rr�r�r�cCst|||||d���S)N�r�r�r�r�)r�r)r�r�r�r�r�rrr�_load�s�rcCs2t|t�rtd��t�|�}t|||||d���S)Nz%Can't load pickle from unicode stringr)r�r�r�rrrsr�r)�sr�r�r�r�r�rrr�_loads�s  �r) r r rrrrrrrcCsddl}|��Sr�)�doctestZtestmod)rrrr�_test�srr�z$display contents of the pickle files)Z description� pickle_file�br�*zthe pickle file)r��nargs�helpz-tz--test� store_truezrun self-test suite)�actionrz-vz)run verbosely; only affects self-test run)N)N)�r�typesr�copyregrrrr� itertoolsr� functoolsrr�r Zstructr r rjrrr/r{�__all__�_picklerr�rrsr.r5r�Zformat_versionZcompatible_formatsr�r�� Exceptionr r rrZorg.python.corer%rPr�r rSrr)r#r rr$rrr�r�rrr r rMrKrYr rzrar`r]r�r�r r�rVrUrr�r�r�rcrQrOrdr(rrr�r rurvrwr rr rrr!r"rRr2r0rIrJr1rirjrnrryr�r�r6r=r>r��dirror�r�r�r�r�r�r�rrrrrrrrrrrr�argparse�ArgumentParser�parser� add_argumentZFileType� parse_argsrZtestrZ print_helpZpprintr�r�rrrr�sh     �   �    ?; ^]� � 0   ����