ó
|
L\¬Qc C @ s/ d Z d d d g Z d Z d Z d Z d e f d YZ d d l m Z d
|
Z
|
e d d d d d e
|
d d Z d Z e d d d d d e d d Z d Z e d d d d d e d d Z e e d Z e d d d e d e d d Z d Z e d d d e d e d d Z d Z e d d! d e d e d d" Z d# Z e d d$ d e d e d d% Z d& Z e d d' d e d e d d( Z d) Z e d d* d e d e d d+ Z d, Z e d d- d e d e d d. Z d/ Z d0 Z e d d1 d e d e d d2 Z! e d d3 d e d e d d4 Z" d5 Z# e d d6 d e d e# d d7 Z$ d8 Z% e d d9 d d: d e% d d; Z& d d< l' m( Z( d= Z) e d d> d e d e) d d? Z* d@ Z+ e d dA d e d e+ d dB Z, dC e f dD YZ- e- d dE dF e. d dG Z/ e- d dH dF e0 d dI Z1 e- d dJ dF e. e0 e2 f d dK Z3 e- d dL dF e2 f d dM Z4 e- d dN dF e5 d dO Z6 e- d dP dF e7 d dQ Z8 e- d dR dF e9 d dS Z: e- d dT dF e; d d dU Z= e- d dV dF e> d dW Z? e- d dX dF e@ d dY ZA e- d dZ dF eB d d[ ZC e- d d\ dF e d d] ZD e- d d^ dF e- d d_ ZE e- d d` dF e- d da ZF db e f dc YZG eG ZH eH d dd de df dg e! dh g di e3 g dj dk d dl eH d dm de dn dg e dh g di e/ g dj d d do eH d dp de dq dg e dh g di e/ g dj d d dr eH d ds de dt dg e dh g di e/ g dj d d du eH d dv de dw dg e" dh g di e1 g dj dk d dx eH d dy de dz dg e* dh g di e1 g dj d d d{ eH d d| de d} dg e, dh g di e1 g dj d d d~ eH d d de d dg e dh g di e8 g dj dk d d eH d d de d dg e dh g di e8 g dj d d d eH d d
de d dg e dh g di e8 g dj d d d eH d d de d dg ddh g di e= g dj dk d d eH d d de d dg ddh g di e4 g dj d d d eH d d de d dg ddh g di e4 g dj d d d eH d d de d dg e dh g di e: g dj dk d d eH d d de d dg e dh g di e: g dj d d d eH d d de d dg e$ dh g di e6 g dj dk d d eH d d de d dg e& dh g di e6 g dj d d d eH d d de d dg ddh g di eA g dj d d d eH d d de d¡ dg ddh eA eD g di eA g dj dk d d¢ eH d d£ de d¤ dg ddh eA eE eF g di eA g dj d d d¥ eH d d¦ de d§ dg ddh eE eF g di eA g dj dk d d¨ eH d d© de dª dg ddh g di e? g dj d d d« eH d d¬ de d dg ddh eE eF g di e? g dj dk d d® eH d d¯ de d° dg ddh eD g di e? g dj d d d± eH d d² de d³ dg ddh eD eD g di e? g dj d d d´ eH d dµ de d¶ dg ddh eD eD eD g di e? g dj d d d· eH d d¸ de d¹ dg ddh g di eC g dj d d dº eH d d» de d¼ dg ddh eE eF g di eC g dj dk d d½ eH d d¾ de d¿ dg ddh eC eD eD g di eC g dj dk d dÀ eH d dÁ de d dg ddh eC eE eF g di eC g dj d d dà eH d dÄ de dÅ dg ddh eD g di g dj dk d dÆ eH d dÇ de dÈ dg ddh eD g di eD eD g dj dk d dÉ eH d dÊ de dË dg ddh g di eE g dj dk d dÌ eH d dÍ de dÎ dg ddh eE eF g di g dj d d dÏ eH d dÐ de dÑ dg e! dh g di eD g dj dk d dÒ eH d dÓ de dÔ dg e dh g di eD g dj d d dÕ eH d dÖ de d× dg e dh g di eD g dj d d dØ eH d dÙ de dÚ dg e! dh g di g dj dk d dÛ eH d dÜ de dÝ dg e dh g di g dj d d dÞ eH d dß de dà dg e dh g di g dj d d dá eH d dâ de dã dg e dh g di eD g dj d d dä eH d då de dæ dg e dh g di eD g dj d d dç eH d dè de dé dg e dh g di eD g dj d d dê eH d dë de dì dg e dh g di eD g dj dk d dí eH d dî de dï dg ddh eD eD g di eD g dj dk d dð eH d dñ de dò dg ddh eD eD g di eD g dj dk d dó eH d dô de dõ dg e dh eE eF g di eD g dj dk d dö eH d d÷ de dø dg ddh eE eD eF g di eD g dj d d dù eH d dú de dû dg ddh eD eD g di eD g dj d d dü eH d dý de dþ dg e dh g di g dj d d dÿ eH d d de ddg ddh eD g di g dj dk d d eH d dde ddg e dh g di eD g dj dk d d eH d dde ddg ddh eD g di eD g dj d d d g5 ZI [H i ZJ i ZK x eL eI D] \ ZM ZN eN jO eJ k reP d eN jO eJ eN jO eM f n eN jQ eK k rNeP d
|
eN jQ eK eN jQ eM f n eM eJ eN jO <eM eK eN jQ <qØW[J [K [M [N i ZR x eI D] ZN eN eR eN jQ <q
W[N eS d ZT eT [T d ZU d ZV ddd d ZW ddd YZX dZY dZZ i eY d6eZ d6Z[ d Z\ e] dk r+e\ n dS( sr "Executable documentation" for the pickle module.
|
|
Extensive comments about the pickle protocols and pickle-machine opcodes
|
can be found here. Some functions meant for external use:
|
|
genops(pickle)
|
Generate all the opcodes in a pickle, as (opcode, arg, position) triples.
|
|
dis(pickle, out=None, memo=None, indentlevel=4)
|
Print a symbolic disassembly of a pickle.
|
t dist genopst optimizeiÿÿÿÿiþÿÿÿiýÿÿÿt ArgumentDescriptorc B s e Z d Z d Z RS( t namet nt readert docc C s t | t s t | | _ t | t rN | d k sT | t t t f k sT t | | _ | | _ t | t s{ t | | _
|
d S( Ni ( t
|
isinstancet strt AssertionErrorR t intt UP_TO_NEWLINEt TAKEN_FROM_ARGUMENT1t TAKEN_FROM_ARGUMENT4R R R ( t selfR R R R ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt __init__¸ s ( s nameR s readers doc( t __name__t
|
__module__t __slots__R ( ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyR ¥ s
|
( t unpackc C s/ | j d } | r t | St d d S( sS
|
>>> import StringIO
|
>>> read_uint1(StringIO.StringIO('\xff'))
|
255
|
i s' not enough data in stream to read uint1N( t readt ordt
|
ValueError( t ft data( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt
|
read_uint1É s
|
R t uint1R i R R s One-byte unsigned integer.c C sB | j d } t | d k r2 t d | d St d d S( s
|
>>> import StringIO
|
>>> read_uint2(StringIO.StringIO('\xff\x00'))
|
255
|
>>> read_uint2(StringIO.StringIO('\xff\xff'))
|
65535
|
i s <Hi s' not enough data in stream to read uint2N( R t lent _unpackR ( R R ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt
|
read_uint2Ü s t uint2i s) Two-byte unsigned integer, little-endian.c C sB | j d } t | d k r2 t d | d St d d S( s¬
|
>>> import StringIO
|
>>> read_int4(StringIO.StringIO('\xff\x00\x00\x00'))
|
255
|
>>> read_int4(StringIO.StringIO('\x00\x00\x00\x80')) == -(2**31)
|
True
|
i s <ii s& not enough data in stream to read int4N( R R R R ( R R ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt read_int4ñ s t int4i s8 Four-byte signed integer, little-endian, 2's complement.c C s | j } | j d s* t d n | d } | r¦ xi d D]N } | j | rA | j | s~ t d | | f n | d d !} PqA qA Wt d | n | r¾ | j d } n | S( s
|
>>> import StringIO
|
>>> read_stringnl(StringIO.StringIO("'abcd'\nefg\n"))
|
'abcd'
|
|
>>> read_stringnl(StringIO.StringIO("\n"))
|
Traceback (most recent call last):
|
...
|
ValueError: no string quotes around ''
|
|
>>> read_stringnl(StringIO.StringIO("\n"), stripquotes=False)
|
''
|
|
>>> read_stringnl(StringIO.StringIO("''\n"))
|
''
|
|
>>> read_stringnl(StringIO.StringIO('"abcd"'))
|
Traceback (most recent call last):
|
...
|
ValueError: no newline found when trying to read stringnl
|
|
Embedded escapes are undone in the result.
|
>>> read_stringnl(StringIO.StringIO(r"'a\n\\b\x00c\td'" + "\n'e'"))
|
'a\n\\b\x00c\td'
|
s
|
s- no newline found when trying to read stringnliÿÿÿÿs '"s, strinq quote %r not found at both ends of %ri s no string quotes around %rt string_escape( t readlinet endswithR t
|
startswitht decode( R R& t stripquotesR t q( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt read_stringnl s
|
t stringnls¢ A newline-terminated string.
|
|
This is a repr-style string, with embedded escapes, and
|
bracketing quotes.
|
c C s t | d t d t S( NR& R' ( R) t False( R ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt read_stringnl_noescapeA s t stringnl_noescapes A newline-terminated string.
|
|
This is a str-style string, without embedded escapes,
|
or bracketing quotes. It should consist solely of
|
printable ASCII characters.
|
c C s d t | t | f S( s|
|
>>> import StringIO
|
>>> read_stringnl_noescape_pair(StringIO.StringIO("Queue\nEmpty\njunk"))
|
'Queue Empty'
|
s %s %s( R, ( R ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt read_stringnl_noescape_pairO s t stringnl_noescape_pairs¶ A pair of newline-terminated strings.
|
|
These are str-style strings, without embedded
|
escapes, or bracketing quotes. They should
|
consist solely of printable ASCII characters.
|
The pair is returned as a single string, with
|
a single blank separating the two strings.
|
c C sp t | } | d k r+ t d | n | j | } t | | k rP | St d | t | f d S( sh
|
>>> import StringIO
|
>>> read_string4(StringIO.StringIO("\x00\x00\x00\x00abc"))
|
''
|
>>> read_string4(StringIO.StringIO("\x03\x00\x00\x00abcdef"))
|
'abc'
|
>>> read_string4(StringIO.StringIO("\x00\x00\x00\x03abcdef"))
|
Traceback (most recent call last):
|
...
|
ValueError: expected 50331648 bytes in a string4, but only 6 remain
|
i s string4 byte count < 0: %ds2 expected %d bytes in a string4, but only %d remainN( R R R R ( R R R ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt read_string4e s t string4sÙ A counted string.
|
|
The first argument is a 4-byte little-endian signed int giving
|
the number of bytes in the string, and the second argument is
|
that many bytes.
|
c C sc t | } | d k s t | j | } t | | k rC | St d | t | f d S( s
|
>>> import StringIO
|
>>> read_string1(StringIO.StringIO("\x00"))
|
''
|
>>> read_string1(StringIO.StringIO("\x03abcdef"))
|
'abc'
|
i s2 expected %d bytes in a string1, but only %d remainN( R R
|
R R R ( R R R ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt read_string1 s t string1sÍ A counted string.
|
|
The first argument is a 1-byte unsigned int giving the number
|
of bytes in the string, and the second argument is that many
|
bytes.
|
c C sA | j } | j d s* t d n | d } t | d S( sq
|
>>> import StringIO
|
>>> read_unicodestringnl(StringIO.StringIO("abc\uabcd\njunk"))
|
u'abc\uabcd'
|
s
|
s4 no newline found when trying to read unicodestringnliÿÿÿÿs raw-unicode-escape( R# R$ R t unicode( R R ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt read_unicodestringnl¤ s
|
|
t unicodestringnlsø A newline-terminated Unicode string.
|
|
This is raw-unicode-escape encoded, so consists of
|
printable ASCII characters, and may contain embedded
|
escape sequences.
|
c C sy t | } | d k r+ t d | n | j | } t | | k rY t | d St d | t | f d S( sÒ
|
>>> import StringIO
|
>>> s = u'abcd\uabcd'
|
>>> enc = s.encode('utf-8')
|
>>> enc
|
'abcd\xea\xaf\x8d'
|
>>> n = chr(len(enc)) + chr(0) * 3 # little-endian 4-byte length
|
>>> t = read_unicodestring4(StringIO.StringIO(n + enc + 'junk'))
|
>>> s == t
|
True
|
|
>>> read_unicodestring4(StringIO.StringIO(n + enc[:-1]))
|
Traceback (most recent call last):
|
...
|
ValueError: expected 7 bytes in a unicodestring4, but only 6 remain
|
i s! unicodestring4 byte count < 0: %ds utf-8s9 expected %d bytes in a unicodestring4, but only %d remainN( R R R R R4 ( R R R ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt read_unicodestring4½ s t unicodestring4sA A counted Unicode string.
|
|
The first argument is a 4-byte little-endian signed int
|
giving the number of bytes in the string, and the second
|
argument-- the UTF-8 encoding of the Unicode string --
|
contains that many bytes.
|
c C s t | d t d t } | j d r: t d | n | d k rJ t S| d k rZ t Sy t | SWn t k
|
r t | SXd S( s
|
>>> import StringIO
|
>>> read_decimalnl_short(StringIO.StringIO("1234\n56"))
|
1234
|
|
>>> read_decimalnl_short(StringIO.StringIO("1234L\n56"))
|
Traceback (most recent call last):
|
...
|
ValueError: trailing 'L' not allowed in '1234L'
|
R& R' t Ls trailing 'L' not allowed in %rt 00t 01N( R) R+ R$ R t TrueR t OverflowErrort long( R t s( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt read_decimalnl_shortå s c C sD t | d t d t } | j d s: t d | n t | S( s³
|
>>> import StringIO
|
|
>>> read_decimalnl_long(StringIO.StringIO("1234\n56"))
|
Traceback (most recent call last):
|
...
|
ValueError: trailing 'L' required in '1234'
|
|
Someday the trailing 'L' will probably go away from this output.
|
|
>>> read_decimalnl_long(StringIO.StringIO("1234L\n56"))
|
1234L
|
|
>>> read_decimalnl_long(StringIO.StringIO("123456789012345678901234L\n6"))
|
123456789012345678901234L
|
R& R' R9 s trailing 'L' required in %r( R) R+ R$ R R> ( R R? ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt read_decimalnl_long s t decimalnl_shorts A newline-terminated decimal integer literal.
|
|
This never has a trailing 'L', and the integer fit
|
in a short Python int on the box where the pickle
|
was written -- but there's no guarantee it will fit
|
in a short Python int on the box where the pickle
|
is read.
|
t decimalnl_longs» A newline-terminated decimal integer literal.
|
|
This has a trailing 'L', and can represent integers
|
of any size.
|
c C s" t | d t d t } t | S( s[
|
>>> import StringIO
|
>>> read_floatnl(StringIO.StringIO("-1.25\n6"))
|
-1.25
|
R& R' ( R) R+ t float( R R? ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt read_floatnl2 s t floatnls A newline-terminated decimal floating literal.
|
|
In general this requires 17 significant digits for roundtrip
|
identity, and pickling then unpickling infinities, NaNs, and
|
minus zero doesn't work across boxes, or on some boxes even
|
on itself (e.g., Windows can't read the strings it produces
|
for infinities or NaNs).
|
c C sB | j d } t | d k r2 t d | d St d d S( s¼
|
>>> import StringIO, struct
|
>>> raw = struct.pack(">d", -1.25)
|
>>> raw
|
'\xbf\xf4\x00\x00\x00\x00\x00\x00'
|
>>> read_float8(StringIO.StringIO(raw + "\n"))
|
-1.25
|
i s >di s( not enough data in stream to read float8N( R R R R ( R R ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt read_float8H s
|
t float8i s An 8-byte binary representation of a float, big-endian.
|
|
The format is unique to Python, and shared with the struct
|
module (format string '>d') "in theory" (the struct and cPickle
|
implementations don't share the code -- they should). It's
|
strongly related to the IEEE-754 double format, and, in normal
|
cases, is in fact identical to the big-endian 754 double format.
|
On other boxes the dynamic range is limited to that of a 754
|
double, and "add a half and chop" rounding is used to reduce
|
the precision to 53 bits. However, even on a 754 box,
|
infinities, NaNs, and minus zero may not be handled correctly
|
(may not survive roundtrip pickling intact).
|
( t decode_longc C sF t | } | j | } t | | k r< t d n t | S( sT
|
>>> import StringIO
|
>>> read_long1(StringIO.StringIO("\x00"))
|
0L
|
>>> read_long1(StringIO.StringIO("\x02\xff\x00"))
|
255L
|
>>> read_long1(StringIO.StringIO("\x02\xff\x7f"))
|
32767L
|
>>> read_long1(StringIO.StringIO("\x02\x00\xff"))
|
-256L
|
>>> read_long1(StringIO.StringIO("\x02\x00\x80"))
|
-32768L
|
s' not enough data in stream to read long1( R R R R RI ( R R R ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt
|
read_long1n s
|
t long1s A binary long, little-endian, using 1-byte size.
|
|
This first reads one byte as an unsigned size, then reads that
|
many bytes and interprets them as a little-endian 2's-complement long.
|
If the size is 0, that's taken as a shortcut for the long 0L.
|
c C se t | } | d k r+ t d | n | j | } t | | k r[ t d n t | S( s
|
>>> import StringIO
|
>>> read_long4(StringIO.StringIO("\x02\x00\x00\x00\xff\x00"))
|
255L
|
>>> read_long4(StringIO.StringIO("\x02\x00\x00\x00\xff\x7f"))
|
32767L
|
>>> read_long4(StringIO.StringIO("\x02\x00\x00\x00\x00\xff"))
|
-256L
|
>>> read_long4(StringIO.StringIO("\x02\x00\x00\x00\x00\x80"))
|
-32768L
|
>>> read_long1(StringIO.StringIO("\x00\x00\x00\x00"))
|
0L
|
i s long4 byte count < 0: %ds' not enough data in stream to read long4( R R R R RI ( R R R ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt
|
read_long4 s t long4s A binary representation of a long, little-endian.
|
|
This first reads four bytes as a signed size (but requires the
|
size to be >= 0), then reads that many bytes and interprets them
|
as a little-endian 2's-complement long. If the size is 0, that's taken
|
as a shortcut for the long 0L, although LONG1 should really be used
|
then instead (and in any case where # of bytes < 256).
|
t StackObjectc B s e Z d Z d Z d Z RS( R t obtypeR c C s¥ t | t s t | | _ t | t sB t | t sB t t | t rz x& | D] } t | t sX t qX Wn | | _ t | t s t | | _ d S( N( R R R
|
R t typet tupleRO R ( R R RO R t contained( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyR Æ s $ c C s | j S( N( R ( R ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt __repr__Ó s ( s names obtypes doc( R R R R RS ( ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyRN ¹ s
|
R RO s3 A short (as opposed to long) Python integer object.R> s3 A long (as opposed to short) Python integer object.t int_or_bools: A Python integer object (short or long), or a Python bool.t bools A Python bool object.RD s A Python float object.R s A Python string object.R4 s A Python Unicode string object.t Nones The Python None object.RQ s A Python tuple object.t lists A Python list object.t dicts A Python dict object.t anys Any kind of object whatsoever.t marks 'The mark' is a unique object.
|
|
Opcodes that operate on a variable number of objects
|
generally don't embed the count of objects in the opcode,
|
or pull it off the stack. Instead the MARK opcode is used
|
to push a special marker object on the stack, and then
|
some other opcodes grab all the objects from the top of
|
the stack down to (but not including) the topmost marker
|
object.
|
t
|
stackslicesK An object representing a contiguous slice of the stack.
|
|
This is used in conjuction with markobject, to represent all
|
of the stack following the topmost markobject. For example,
|
the POP_MARK opcode changes the stack from
|
|
[..., markobject, stackslice]
|
to
|
[...]
|
|
No matter how many object are on the stack after the topmost
|
markobject, POP_MARK gets rid of all of them (including the
|
topmost markobject too).
|
t
|
OpcodeInfoc B s e Z d Z d Z RS( R t codet argt stack_beforet stack_aftert protoR c C sb t | t s t | | _ t | t s3 t t | d k sK t | | _ | d k su t | t su t | | _ t | t s t x# | D] } t | t
|
s t q W| | _ t | t s× t x# | D] } t | t
|
sÞ t qÞ W| | _ t | t r1d | k o,d k n s7t | | _ t | t sUt | | _ d S( Ni i i ( R R R
|
R R R] RV R R^ RW RN R_ R` R Ra R ( R R R] R^ R_ R` Ra R t x( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyR V s& ! 1 ( s names codes args stack_befores stack_afters protos doc( R R R R ( ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyR\ 7 s t INTR] t IR^ R_ R` Ra i s¤ Push an integer or bool.
|
|
The argument is a newline-terminated decimal literal string.
|
|
The intent may have been that this always fit in a short Python int,
|
but INT can be generated in pickles written on a 64-bit box that
|
require a Python long on a 32-bit box. The difference between this
|
and LONG then is that INT skips a trailing 'L', and produces a short
|
int whenever possible.
|
|
Another difference is due to that, when bool was introduced as a
|
distinct type in 2.3, builtin names True and False were also added to
|
2.2.2, mapping to ints 1 and 0. For compatibility in both directions,
|
True gets pickled as INT + "I01\n", and False as INT + "I00\n".
|
Leading zeroes are never produced for a genuine integer. The 2.3
|
(and later) unpicklers special-case these and return bool instead;
|
earlier unpicklers ignore the leading "0" and return the int.
|
t BININTt Js1 Push a four-byte signed integer.
|
|
This handles the full range of Python (short) integers on a 32-bit
|
box, directly as binary bytes (1 for the opcode and 4 for the integer).
|
If the integer is non-negative and fits in 1 or 2 bytes, pickling via
|
BININT1 or BININT2 saves space.
|
t BININT1t Ks Push a one-byte unsigned integer.
|
|
This is a space optimization for pickling very small non-negative ints,
|
in range(256).
|
t BININT2t Msë Push a two-byte unsigned integer.
|
|
This is a space optimization for pickling small positive ints, in
|
range(256, 2**16). Integers in range(256) can also be pickled via
|
BININT2, but BININT1 instead saves a byte.
|
t LONGR9 sÇ Push a long integer.
|
|
The same as INT, except that the literal ends with 'L', and always
|
unpickles to a Python long. There doesn't seem a real purpose to the
|
trailing 'L'.
|
|
Note that LONG takes time quadratic in the number of digits when
|
unpickling (this is simply due to the nature of decimal->binary
|
conversion). Proto 2 added linear-time (in C; still quadratic-time
|
in Python) LONG1 and LONG4 opcodes.
|
t LONG1s s| Long integer using one-byte length.
|
|
A more efficient encoding of a Python long; the long1 encoding
|
says it all.t LONG4s s~ Long integer using found-byte length.
|
|
A more efficient encoding of a Python long; the long4 encoding
|
says it all.t STRINGt SsÓ Push a Python string object.
|
|
The argument is a repr-style string, with bracketing quote characters,
|
and perhaps embedded escapes. The argument extends until the next
|
newline character.
|
t BINSTRINGt Tsý Push a Python string object.
|
|
There are two arguments: the first is a 4-byte little-endian signed int
|
giving the number of bytes in the string, and the second is that many
|
bytes, which are taken literally as the string content.
|
t SHORT_BINSTRINGt Usñ Push a Python string object.
|
|
There are two arguments: the first is a 1-byte unsigned int giving
|
the number of bytes in the string, and the second is that many bytes,
|
which are taken literally as the string content.
|
t NONEt Ns Push None on the stack.t NEWTRUEs s& True.
|
|
Push True onto the stack.t NEWFALSEs s' True.
|
|
Push False onto the stack.t UNICODEt Vsç Push a Python Unicode string object.
|
|
The argument is a raw-unicode-escape encoding of a Unicode string,
|
and so may contain embedded escape sequences. The argument extends
|
until the next newline character.
|
t
|
BINUNICODEt Xs Push a Python Unicode string object.
|
|
There are two arguments: the first is a 4-byte little-endian signed int
|
giving the number of bytes in the string. The second is that many
|
bytes, and is the UTF-8 encoding of the Unicode string.
|
t FLOATt Fs Newline-terminated decimal float literal.
|
|
The argument is repr(a_float), and in general requires 17 significant
|
digits for roundtrip conversion to be an identity (this is so for
|
IEEE-754 double precision values, which is what Python float maps to
|
on most boxes).
|
|
In general, FLOAT cannot be used to transport infinities, NaNs, or
|
minus zero across boxes (or even on a single box, if the platform C
|
library can't read the strings it produces for such things -- Windows
|
is like that), but may do less damage than BINFLOAT on boxes with
|
greater precision or dynamic range than IEEE-754 double.
|
t BINFLOATt GsÜ Float stored in binary form, with 8 bytes of data.
|
|
This generally requires less than half the space of FLOAT encoding.
|
In general, BINFLOAT cannot be used to transport infinities, NaNs, or
|
minus zero, raises an exception if the exponent exceeds the range of
|
an IEEE-754 double, and retains no more than 53 bits of precision (if
|
there are more than that, "add a half and chop" rounding is used to
|
cut it back to 53 significant bits).
|
t
|
EMPTY_LISTt ]s Push an empty list.t APPENDt as Append an object to a list.
|
|
Stack before: ... pylist anyobject
|
Stack after: ... pylist+[anyobject]
|
|
although pylist is really extended in-place.
|
t APPENDSt esÇ Extend a list by a slice of stack objects.
|
|
Stack before: ... pylist markobject stackslice
|
Stack after: ... pylist+stackslice
|
|
although pylist is really extended in-place.
|
t LISTt lss Build a list out of the topmost stack slice, after markobject.
|
|
All the stack entries following the topmost markobject are placed into
|
a single Python list, which single list object replaces all of the
|
stack from the topmost markobject onward. For example,
|
|
Stack before: ... markobject 1 2 3 'abc'
|
Stack after: ... [1, 2, 3, 'abc']
|
t EMPTY_TUPLEt )s Push an empty tuple.t TUPLEt tsv Build a tuple out of the topmost stack slice, after markobject.
|
|
All the stack entries following the topmost markobject are placed into
|
a single Python tuple, which single tuple object replaces all of the
|
stack from the topmost markobject onward. For example,
|
|
Stack before: ... markobject 1 2 3 'abc'
|
Stack after: ... (1, 2, 3, 'abc')
|
t TUPLE1s
sü Build a one-tuple out of the topmost item on the stack.
|
|
This code pops one value off the stack and pushes a tuple of
|
length 1 whose one item is that value back onto it. In other
|
words:
|
|
stack[-1] = tuple(stack[-1:])
|
t TUPLE2s s Build a two-tuple out of the top two items on the stack.
|
|
This code pops two values off the stack and pushes a tuple of
|
length 2 whose items are those values back onto it. In other
|
words:
|
|
stack[-2:] = [tuple(stack[-2:])]
|
t TUPLE3s s Build a three-tuple out of the top three items on the stack.
|
|
This code pops three values off the stack and pushes a tuple of
|
length 3 whose items are those values back onto it. In other
|
words:
|
|
stack[-3:] = [tuple(stack[-3:])]
|
t
|
EMPTY_DICTt }s Push an empty dict.t DICTt ds² Build a dict out of the topmost stack slice, after markobject.
|
|
All the stack entries following the topmost markobject are placed into
|
a single Python dict, which single dict object replaces all of the
|
stack from the topmost markobject onward. The stack slice alternates
|
key, value, key, value, .... For example,
|
|
Stack before: ... markobject 1 2 3 'abc'
|
Stack after: ... {1: 2, 3: 'abc'}
|
t SETITEMR? sº Add a key+value pair to an existing dict.
|
|
Stack before: ... pydict key value
|
Stack after: ... pydict
|
|
where pydict has been modified via pydict[key] = value.
|
t SETITEMSt us\ Add an arbitrary number of key+value pairs to an existing dict.
|
|
The slice of the stack following the topmost markobject is taken as
|
an alternating sequence of keys and values, added to the dict
|
immediately under the topmost markobject. Everything at and after the
|
topmost markobject is popped, leaving the mutated dict at the top
|
of the stack.
|
|
Stack before: ... pydict markobject key_1 value_1 ... key_n value_n
|
Stack after: ... pydict
|
|
where pydict has been modified via pydict[key_i] = value_i for i in
|
1, 2, ..., n, and in that order.
|
t POPt 0s< Discard the top stack item, shrinking the stack by one item.t DUPt 2s= Push the top stack item onto the stack again, duplicating it.t MARKt (sò Push markobject onto the stack.
|
|
markobject is a unique object, used by other opcodes to identify a
|
region of the stack containing a variable number of objects for them
|
to work on. See markobject.doc for more detail.
|
t POP_MARKt 1s Pop all the stack objects at and above the topmost markobject.
|
|
When an opcode using a variable number of stack objects is done,
|
POP_MARK is used to remove those objects, and to remove the markobject
|
that delimited their starting position on the stack.
|
t GETt gsè Read an object from the memo and push it on the stack.
|
|
The index of the memo object to push is given by the newline-terminated
|
decimal string following. BINGET and LONG_BINGET are space-optimized
|
versions.
|
t BINGETt hs¢ Read an object from the memo and push it on the stack.
|
|
The index of the memo object to push is given by the 1-byte unsigned
|
integer following.
|
t LONG_BINGETt js® Read an object from the memo and push it on the stack.
|
|
The index of the memo object to push is given by the 4-byte signed
|
little-endian integer following.
|
t PUTt ps÷ Store the stack top into the memo. The stack is not popped.
|
|
The index of the memo location to write into is given by the newline-
|
terminated decimal string following. BINPUT and LONG_BINPUT are
|
space-optimized versions.
|
t BINPUTR( s° Store the stack top into the memo. The stack is not popped.
|
|
The index of the memo location to write into is given by the 1-byte
|
unsigned integer following.
|
t LONG_BINPUTt rs¼ Store the stack top into the memo. The stack is not popped.
|
|
The index of the memo location to write into is given by the 4-byte
|
signed little-endian integer following.
|
t EXT1s s Extension code.
|
|
This code and the similar EXT2 and EXT4 allow using a registry
|
of popular objects that are pickled by name, typically classes.
|
It is envisioned that through a global negotiation and
|
registration process, third parties can set up a mapping between
|
ints and object names.
|
|
In order to guarantee pickle interchangeability, the extension
|
code registry ought to be global, although a range of codes may
|
be reserved for private use.
|
|
EXT1 has a 1-byte integer argument. This is used to index into the
|
extension registry, and the object at that index is pushed on the stack.
|
t EXT2s sN Extension code.
|
|
See EXT1. EXT2 has a two-byte integer argument.
|
t EXT4s sO Extension code.
|
|
See EXT1. EXT4 has a four-byte integer argument.
|
t GLOBALt cs§ Push a global object (module.attr) on the stack.
|
|
Two newline-terminated strings follow the GLOBAL opcode. The first is
|
taken as a module name, and the second as a class name. The class
|
object module.class is pushed on the stack. More accurately, the
|
object returned by self.find_class(module, class) is pushed on the
|
stack, so unpickling subclasses can override this form of lookup.
|
t REDUCEt RsN Push an object built from a callable and an argument tuple.
|
|
The opcode is named to remind of the __reduce__() method.
|
|
Stack before: ... callable pytuple
|
Stack after: ... callable(*pytuple)
|
|
The callable and the argument tuple are the first two items returned
|
by a __reduce__ method. Applying the callable to the argtuple is
|
supposed to reproduce the original object, or at least get it started.
|
If the __reduce__ method returns a 3-tuple, the last component is an
|
argument to be passed to the object's __setstate__, and then the REDUCE
|
opcode is followed by code to create setstate's argument, and then a
|
BUILD opcode to apply __setstate__ to that argument.
|
|
If type(callable) is not ClassType, REDUCE complains unless the
|
callable has been registered with the copy_reg module's
|
safe_constructors dict, or the callable has a magic
|
'__safe_for_unpickling__' attribute with a true value. I'm not sure
|
why it does this, but I've sure seen this complaint often enough when
|
I didn't want to <wink>.
|
t BUILDt bsÈ Finish building an object, via __setstate__ or dict update.
|
|
Stack before: ... anyobject argument
|
Stack after: ... anyobject
|
|
where anyobject may have been mutated, as follows:
|
|
If the object has a __setstate__ method,
|
|
anyobject.__setstate__(argument)
|
|
is called.
|
|
Else the argument must be a dict, the object must have a __dict__, and
|
the object is updated via
|
|
anyobject.__dict__.update(argument)
|
|
This may raise RuntimeError in restricted execution mode (which
|
disallows access to __dict__ directly); in that case, the object
|
is updated instead via
|
|
for k, v in argument.items():
|
anyobject[k] = v
|
t INSTt is Build a class instance.
|
|
This is the protocol 0 version of protocol 1's OBJ opcode.
|
INST is followed by two newline-terminated strings, giving a
|
module and class name, just as for the GLOBAL opcode (and see
|
GLOBAL for more details about that). self.find_class(module, name)
|
is used to get a class object.
|
|
In addition, all the objects on the stack following the topmost
|
markobject are gathered into a tuple and popped (along with the
|
topmost markobject), just as for the TUPLE opcode.
|
|
Now it gets complicated. If all of these are true:
|
|
+ The argtuple is empty (markobject was at the top of the stack
|
at the start).
|
|
+ It's an old-style class object (the type of the class object is
|
ClassType).
|
|
+ The class object does not have a __getinitargs__ attribute.
|
|
then we want to create an old-style class instance without invoking
|
its __init__() method (pickle has waffled on this over the years; not
|
calling __init__() is current wisdom). In this case, an instance of
|
an old-style dummy class is created, and then we try to rebind its
|
__class__ attribute to the desired class object. If this succeeds,
|
the new instance object is pushed on the stack, and we're done. In
|
restricted execution mode it can fail (assignment to __class__ is
|
disallowed), and I'm not really sure what happens then -- it looks
|
like the code ends up calling the class object's __init__ anyway,
|
via falling into the next case.
|
|
Else (the argtuple is not empty, it's not an old-style class object,
|
or the class object does have a __getinitargs__ attribute), the code
|
first insists that the class object have a __safe_for_unpickling__
|
attribute. Unlike as for the __safe_for_unpickling__ check in REDUCE,
|
it doesn't matter whether this attribute has a true or false value, it
|
only matters whether it exists (XXX this is a bug; cPickle
|
requires the attribute to be true). If __safe_for_unpickling__
|
doesn't exist, UnpicklingError is raised.
|
|
Else (the class object does have a __safe_for_unpickling__ attr),
|
the class object obtained from INST's arguments is applied to the
|
argtuple obtained from the stack, and the resulting instance object
|
is pushed on the stack.
|
|
NOTE: checks for __safe_for_unpickling__ went away in Python 2.3.
|
t OBJt osØ Build a class instance.
|
|
This is the protocol 1 version of protocol 0's INST opcode, and is
|
very much like it. The major difference is that the class object
|
is taken off the stack, allowing it to be retrieved from the memo
|
repeatedly if several instances of the same class are created. This
|
can be much more efficient (in both time and space) than repeatedly
|
embedding the module and class names in INST opcodes.
|
|
Unlike INST, OBJ takes no arguments from the opcode stream. Instead
|
the class object is taken off the stack, immediately above the
|
topmost markobject:
|
|
Stack before: ... markobject classobject stackslice
|
Stack after: ... new_instance_object
|
|
As for INST, the remainder of the stack above the markobject is
|
gathered into an argument tuple, and then the logic seems identical,
|
except that no __safe_for_unpickling__ check is done (XXX this is
|
a bug; cPickle does test __safe_for_unpickling__). See INST for
|
the gory details.
|
|
NOTE: In Python 2.3, INST and OBJ are identical except for how they
|
get the class object. That was always the intent; the implementations
|
had diverged for accidental reasons.
|
t NEWOBJs sL Build an object instance.
|
|
The stack before should be thought of as containing a class
|
object followed by an argument tuple (the tuple being the stack
|
top). Call these cls and args. They are popped off the stack,
|
and the value returned by cls.__new__(cls, *args) is pushed back
|
onto the stack.
|
t PROTOs s® Protocol version indicator.
|
|
For protocol 2 and above, a pickle must start with this opcode.
|
The argument is the protocol version, an int in range(2, 256).
|
t STOPt .sÏ Stop the unpickling machine.
|
|
Every pickle ends with this opcode. The object at the top of the stack
|
is popped, and that's the result of unpickling. The stack should be
|
empty then.
|
t PERSIDt Ps Push an object identified by a persistent ID.
|
|
The pickle module doesn't define what a persistent ID means. PERSID's
|
argument is a newline-terminated str-style (no embedded escapes, no
|
bracketing quote characters) string, which *is* "the persistent ID".
|
The unpickler passes this string to self.persistent_load(). Whatever
|
object that returns is pushed on the stack. There is no implementation
|
of persistent_load() in Python's unpickler: it must be supplied by an
|
unpickler subclass.
|
t BINPERSIDt QsX Push an object identified by a persistent ID.
|
|
Like PERSID, except the persistent ID is popped off the stack (instead
|
of being a string embedded in the opcode bytestream). The persistent
|
ID is passed to self.persistent_load(), and whatever object that
|
returns is pushed on the stack. See PERSID for more detail.
|
s% repeated name %r at indices %d and %ds% repeated code %r at indices %d and %dc C s d d l } d d l } t j } x| j D]û } | j d | s^ | r. d | GHq. q. n t | | } t | t s t | d k r | r. d | | f GHq. q. n | | k r| rÑ d | | f GHn | | } | j
|
| k r t d | | | j
|
f n | | =q. t d | | f q. W| rd g } x4 | j D]& \ } } | j d
|
| j
|
| f qIWt d j | n d S( Niÿÿÿÿs [A-Z][A-Z0-9_]+$s0 skipping %r: it doesn't look like an opcode namei s5 skipping %r: value %r doesn't look like a pickle codes+ checking name %r w/ code %r for consistencysB for pickle code %r, pickle.py uses name %r but we're using name %rsP pickle.py appears to have a pickle opcode with name %r and code %r, but we don'ts= we appear to have pickle opcodes that pickle.py doesn't have:s name %r with code %rs
|
( t picklet ret code2opt copyt __all__t matcht getattrR R R R R t itemst appendt join( t verboseR¾ R¿ RÁ R t
|
picklecodeR t msgR] ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt assure_pickle_consistencyã s> "
|
|
c c s8 d d l } t | t r- | j | } n t | d rH | j } n d } xà t r3| } | j d } t j | } | d k rÓ | d k r¨ t d qÓ t d | d k rÀ d pà | | f n | j d k rë d } n | j j | } | | | f V| d
|
k rT | j d k s,t PqT qT Wd S( sz Generate all the opcodes in a pickle.
|
|
'pickle' is a file-like object, or string, containing the pickle.
|
|
Each opcode in the pickle is generated, from the current pickle position,
|
stopping after a STOP opcode is delivered. A triple is generated for
|
each opcode:
|
|
opcode, arg, pos
|
|
opcode is an OpcodeInfo record, describing the current opcode.
|
|
If the opcode has an argument embedded in the pickle, arg is its decoded
|
value, as a Python object. If the opcode doesn't have an argument, arg
|
is None.
|
|
If the pickle has a tell() method, pos was the value of pickle.tell()
|
before reading the current opcode. If the pickle is a string object,
|
it's wrapped in a StringIO object, and the latter's tell() result is
|
used. Else (the pickle doesn't have a tell(), and it's not obvious how
|
to query its current position) pos is None.
|
iÿÿÿÿNt tellc S s d S( N( RV ( ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt <lambda>/ s i t s# pickle exhausted before seeing STOPs! at position %s, opcode %r unknowns <unknown>R¹ R¸ ( t cStringIOR R t StringIOt hasattrRÌ R< R RÀ t getRV R R^ R R R
|
( R¾ RÐ t getpost posR] t opcodeR^ ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyR s. c C s t } g } d } x t | D]x \ } } } | d k r\ | j | | | f d } n d | j k r{ | | } } q" d | j k r" | j | q" q" Wg } d } xI | D]A \ } }
|
} | | k rÒ | n |
|
} | j | | | ! | } q± W| j | | d j | S( s7 Optimize a pickle string by removing unused PUT opcodesR¤ R i RÎ N( t setRV R RÆ R t addRÇ ( R¥ t getst putst prevposRÕ R^ RÔ t prevargR? R³ t startt stopR£ ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyR H s&
|
c
|
C sæ g } | d k r i } n d } g } d | } d } xt | D]q\ } }
|
} | d k rp | d | In d t | j d d !| t | | j f } t | | j } | j } | j } t | } d } t
|
| k s| j d k rì| rì| d t
|
k rìt
|
| k st t
|
| k r>| d t k s>t n | rß| j } | d k red } n
|
d | } x | d t
|
k r| j qrW| j y | j t
|
} Wqét k
|
rÛ| j d k sÒt d } qéXqìd
|
} } n | j d k r_|
|
d k s t |
|
| k r&d |
|
} q¯| s5d } q¯| d t
|
k rNd } q¯| d | |
|
<nP | j d k r¯|
|
| k r¢t | d k st | |
|
g } q¯d |
|
} n |
|
d k sÁ| r| d d t | j 7} |
|
d k rÿ| d t |
|
7} n | r| d | 7} qn | | IJ| r8t | n t | | k rit d | t | f n | rz| | 3n t
|
| k r¨t
|
| k st | j | n | j | qD W| d I| IJ| rât d | n d S( s Produce a symbolic disassembly of a pickle.
|
|
'pickle' is a file-like object, or string, containing a (at least one)
|
pickle. The pickle is disassembled from the current position, through
|
the first STOP opcode encountered.
|
|
Optional arg 'out' is a file-like object to which the disassembly is
|
printed. It defaults to sys.stdout.
|
|
Optional arg 'memo' is a Python dict, used as the pickle's memo. It
|
may be mutated by dis(), if the pickle contains PUT or BINPUT opcodes.
|
Passing the same memo object to another dis() call then allows disassembly
|
to proceed across multiple pickles that were all created by the same
|
pickler with the same memo. Ordinarily you don't need to worry about this.
|
|
Optional arg indentlevel is the number of blanks by which to indent
|
a new MARK level. It defaults to 4.
|
|
In addition to printing the disassembly, some sanity checks are made:
|
|
+ All embedded opcode arguments "make sense".
|
|
+ Explicit and implicit pop operations have enough items on the stack.
|
|
+ When an opcode implicitly refers to a markobject, a markobject is
|
actually on the stack.
|
|
+ A memo entry isn't referenced before it's defined.
|
|
+ The markobject isn't stored in the memo.
|
|
+ A memo entry isn't redefined.
|
iÿÿÿÿt s %5d:s %-4s %s%si R s (MARK at unknown opcode offset)s (MARK at %d)i s no MARK exists on stackR¤ R¦ R§ s memo key %r already defineds' stack is empty -- can't store into memos" can't store markobject in the memoR R R¢ s& memo key %r has never been stored intoi
|
s3 tries to pop %d items from stack with only %d itemss highest protocol among opcodes =s stack not empty after STOP: %rN( s PUTR¦ R§ ( s GETR R¢ ( RV R t reprR] R R t maxRa R_ R` t
|
markobjectR
|
R[ t popt indexR RÆ t extend( R¾ t outt memot indentlevelt stackt maxprotot markstackt indentchunkt errormsgRÕ R^ RÔ t linet beforet aftert numtopopt markmsgt markpos( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyR c s '
|
|
|
|
t _Examplec B s e Z d Z RS( c C s | | _ d S( N( t value( R Rô ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyR í s ( R R R ( ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyRó ì s s
|
>>> import pickle
|
>>> x = [1, 2, (3, 4), {'abc': u"def"}]
|
>>> pkl = pickle.dumps(x, 0)
|
>>> dis(pkl)
|
0: ( MARK
|
1: l LIST (MARK at 0)
|
2: p PUT 0
|
5: I INT 1
|
8: a APPEND
|
9: I INT 2
|
12: a APPEND
|
13: ( MARK
|
14: I INT 3
|
17: I INT 4
|
20: t TUPLE (MARK at 13)
|
21: p PUT 1
|
24: a APPEND
|
25: ( MARK
|
26: d DICT (MARK at 25)
|
27: p PUT 2
|
30: S STRING 'abc'
|
37: p PUT 3
|
40: V UNICODE u'def'
|
45: p PUT 4
|
48: s SETITEM
|
49: a APPEND
|
50: . STOP
|
highest protocol among opcodes = 0
|
|
Try again with a "binary" pickle.
|
|
>>> pkl = pickle.dumps(x, 1)
|
>>> dis(pkl)
|
0: ] EMPTY_LIST
|
1: q BINPUT 0
|
3: ( MARK
|
4: K BININT1 1
|
6: K BININT1 2
|
8: ( MARK
|
9: K BININT1 3
|
11: K BININT1 4
|
13: t TUPLE (MARK at 8)
|
14: q BINPUT 1
|
16: } EMPTY_DICT
|
17: q BINPUT 2
|
19: U SHORT_BINSTRING 'abc'
|
24: q BINPUT 3
|
26: X BINUNICODE u'def'
|
34: q BINPUT 4
|
36: s SETITEM
|
37: e APPENDS (MARK at 3)
|
38: . STOP
|
highest protocol among opcodes = 1
|
|
Exercise the INST/OBJ/BUILD family.
|
|
>>> import pickletools
|
>>> dis(pickle.dumps(pickletools.dis, 0))
|
0: c GLOBAL 'pickletools dis'
|
17: p PUT 0
|
20: . STOP
|
highest protocol among opcodes = 0
|
|
>>> from pickletools import _Example
|
>>> x = [_Example(42)] * 2
|
>>> dis(pickle.dumps(x, 0))
|
0: ( MARK
|
1: l LIST (MARK at 0)
|
2: p PUT 0
|
5: ( MARK
|
6: i INST 'pickletools _Example' (MARK at 5)
|
28: p PUT 1
|
31: ( MARK
|
32: d DICT (MARK at 31)
|
33: p PUT 2
|
36: S STRING 'value'
|
45: p PUT 3
|
48: I INT 42
|
52: s SETITEM
|
53: b BUILD
|
54: a APPEND
|
55: g GET 1
|
58: a APPEND
|
59: . STOP
|
highest protocol among opcodes = 0
|
|
>>> dis(pickle.dumps(x, 1))
|
0: ] EMPTY_LIST
|
1: q BINPUT 0
|
3: ( MARK
|
4: ( MARK
|
5: c GLOBAL 'pickletools _Example'
|
27: q BINPUT 1
|
29: o OBJ (MARK at 4)
|
30: q BINPUT 2
|
32: } EMPTY_DICT
|
33: q BINPUT 3
|
35: U SHORT_BINSTRING 'value'
|
42: q BINPUT 4
|
44: K BININT1 42
|
46: s SETITEM
|
47: b BUILD
|
48: h BINGET 2
|
50: e APPENDS (MARK at 3)
|
51: . STOP
|
highest protocol among opcodes = 1
|
|
Try "the canonical" recursive-object test.
|
|
>>> L = []
|
>>> T = L,
|
>>> L.append(T)
|
>>> L[0] is T
|
True
|
>>> T[0] is L
|
True
|
>>> L[0][0] is L
|
True
|
>>> T[0][0] is T
|
True
|
>>> dis(pickle.dumps(L, 0))
|
0: ( MARK
|
1: l LIST (MARK at 0)
|
2: p PUT 0
|
5: ( MARK
|
6: g GET 0
|
9: t TUPLE (MARK at 5)
|
10: p PUT 1
|
13: a APPEND
|
14: . STOP
|
highest protocol among opcodes = 0
|
|
>>> dis(pickle.dumps(L, 1))
|
0: ] EMPTY_LIST
|
1: q BINPUT 0
|
3: ( MARK
|
4: h BINGET 0
|
6: t TUPLE (MARK at 3)
|
7: q BINPUT 1
|
9: a APPEND
|
10: . STOP
|
highest protocol among opcodes = 1
|
|
Note that, in the protocol 0 pickle of the recursive tuple, the disassembler
|
has to emulate the stack in order to realize that the POP opcode at 16 gets
|
rid of the MARK at 0.
|
|
>>> dis(pickle.dumps(T, 0))
|
0: ( MARK
|
1: ( MARK
|
2: l LIST (MARK at 1)
|
3: p PUT 0
|
6: ( MARK
|
7: g GET 0
|
10: t TUPLE (MARK at 6)
|
11: p PUT 1
|
14: a APPEND
|
15: 0 POP
|
16: 0 POP (MARK at 0)
|
17: g GET 1
|
20: . STOP
|
highest protocol among opcodes = 0
|
|
>>> dis(pickle.dumps(T, 1))
|
0: ( MARK
|
1: ] EMPTY_LIST
|
2: q BINPUT 0
|
4: ( MARK
|
5: h BINGET 0
|
7: t TUPLE (MARK at 4)
|
8: q BINPUT 1
|
10: a APPEND
|
11: 1 POP_MARK (MARK at 0)
|
12: h BINGET 1
|
14: . STOP
|
highest protocol among opcodes = 1
|
|
Try protocol 2.
|
|
>>> dis(pickle.dumps(L, 2))
|
0: \x80 PROTO 2
|
2: ] EMPTY_LIST
|
3: q BINPUT 0
|
5: h BINGET 0
|
7: \x85 TUPLE1
|
8: q BINPUT 1
|
10: a APPEND
|
11: . STOP
|
highest protocol among opcodes = 2
|
|
>>> dis(pickle.dumps(T, 2))
|
0: \x80 PROTO 2
|
2: ] EMPTY_LIST
|
3: q BINPUT 0
|
5: h BINGET 0
|
7: \x85 TUPLE1
|
8: q BINPUT 1
|
10: a APPEND
|
11: 0 POP
|
12: h BINGET 1
|
14: . STOP
|
highest protocol among opcodes = 2
|
sM
|
>>> import pickle
|
>>> from StringIO import StringIO
|
>>> f = StringIO()
|
>>> p = pickle.Pickler(f, 2)
|
>>> x = [1, 2, 3]
|
>>> p.dump(x)
|
>>> p.dump(x)
|
>>> f.seek(0)
|
>>> memo = {}
|
>>> dis(f, memo=memo)
|
0: \x80 PROTO 2
|
2: ] EMPTY_LIST
|
3: q BINPUT 0
|
5: ( MARK
|
6: K BININT1 1
|
8: K BININT1 2
|
10: K BININT1 3
|
12: e APPENDS (MARK at 5)
|
13: . STOP
|
highest protocol among opcodes = 2
|
>>> dis(f, memo=memo)
|
14: \x80 PROTO 2
|
16: h BINGET 0
|
18: . STOP
|
highest protocol among opcodes = 2
|
t disassembler_testt disassembler_memo_testc C s d d l } | j S( Niÿÿÿÿ( t doctestt testmod( R÷ ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt _testÝ s t __main__N( (^ t __doc__RÂ R R R t objectR t structR R R R R R R R! R< R) R* R, R- R. R/ R0 R1 R2 R3 R5 R6 R7 R8 R@ RA RB RC RE RF RG RH R¾ RI RJ RK RL RM RN R t pyintR> t pylongRU t pyinteger_or_boolt pyboolRD t pyfloatR t pystringR4 t pyunicodeRP RV t pynoneRQ t pytupleRW t pylistRX t pydictt anyobjectRá R[ R\ Rd t opcodest name2it code2it enumerateR³ R R R R] RÀ R+ RË R R R Ró t _dis_testt
|
_memo_testt __test__Rù R ( ( ( sS /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/pickletools.pyt <module> sh " 1
|
;
|
1
|
& 9 Ï
|
|
|
