summaryrefslogtreecommitdiffstats
path: root/Lib/pickle.py
Commit message (Collapse)AuthorAgeFilesLines
...
* Linear-time implementations of {encode,decode}_long.Tim Peters2003-01-311-19/+50
|
* load_inst(), load_obj(): Put the bulk of these into a common newTim Peters2003-01-301-26/+18
| | | | _instantiate() method.
* There was a subtle big in save_newobj(): it used self.save_global(t)Guido van Rossum2003-01-301-1/+2
| | | | | | | | | | | | | | | on the type instead of self.save(t). This defeated the purpose of NEWOBJ, because it didn't generate a BINGET opcode when t was already memoized; but moreover, it would generate multiple BINPUT opcodes for the same type! pickletools.dis() doesn't like this. How I found this? I was playing with picklesize.py in the datetime sandbox, and noticed that protocol 2 pickles for multiple objects were in fact larger than protocol 1 pickles! That was suspicious, so I decided to disassemble one of the pickles. This really needs a unit test, but I'm exhausted. I'll be late for work as it is. :-(
* Slight code rearrangement to avoid testing getstate twice.Guido van Rossum2003-01-301-22/+23
|
* In save_newobj(), if an object's __getnewargs__ and __getstate__ areGuido van Rossum2003-01-301-0/+23
| | | | | | | | | the same function, don't save the state or write a BUILD opcode. This is so that a type (e.g. datetime :-) can support protocol 2 using __getnewargs__ while also supporting protocol 0 and 1 using __getstate__. (Without this, the state would be pickled twice with protocol 2, unless __getstate__ is defined to return None, which breaks protocol 0 and 1.)
* Use %c rather than chr() to turn some ints into chars.Guido van Rossum2003-01-291-2/+2
|
* Implement appropriate __getnewargs__ for all immutable subclassable builtinGuido van Rossum2003-01-291-8/+4
| | | | | | | | types. The special handling for these can now be removed from save_newobj(). Add some testing for this. Also add support for setting the 'fast' flag on the Python Pickler class, which suppresses use of the memo.
* Declare Protocol 2 as implemented.Guido van Rossum2003-01-291-1/+1
|
* Support for extension codes. (By accident I checked in the tests first.)Guido van Rossum2003-01-291-8/+63
|
* pickle: Comment repair.Tim Peters2003-01-291-4/+9
| | | | pickletools: Import decode_long from pickle instead of duplicating it.
* Add a comment about how some built-in types should grow aGuido van Rossum2003-01-281-1/+3
| | | | __getnewargs__ method.
* Get rid of __safe_for_unpickling__ and safe_constructors.Guido van Rossum2003-01-281-28/+12
| | | | Also tidied up a few lines, got rid of apply(), added a comment.
* Instead of bad hacks trying to worm around the inheritedGuido van Rossum2003-01-281-37/+79
| | | | | | | | | | | | | object.__reduce__, do a getattr() on the class so we can explicitly test for it. The reduce()-calling code becomes a bit more regular as a result. Also add support slots: if an object has slots, the default state is (dict, slots) where dict is the __dict__ or None, and slots is a dict mapping slot names to slot values. We do a best-effort approach to find slot names, assuming the __slots__ fields of classes aren't modified after class definition time to misrepresent the actual list of slots defined by a class.
* The default __reduce__ on the base object type obscured anyGuido van Rossum2003-01-281-7/+39
| | | | | | possibility of calling save_reduce(). Add a special hack for this. The tests for this are much simpler now (no __getstate__ or __getnewargs__ needed).
* Move the NEWOBJ-generating code to a separate function, and invoke itGuido van Rossum2003-01-281-24/+28
| | | | after checking for __reduce__.
* Some experimental support for generating NEWOBJ with proto=2, andGuido van Rossum2003-01-281-2/+31
| | | | fixed a bug in load_newobj().
* save_empty_tuple(): Comment on why we can't get rid of this.Tim Peters2003-01-281-0/+3
|
* save_dict(): Added a comment about the control flow NealN missed.Tim Peters2003-01-281-1/+2
|
* _is_string_secure(): This method is no longer used; removed it. (ItTim Peters2003-01-281-37/+0
| | | | was used before string-escape codecs were added to the core.)
* Made save() fit on a page, while adding comments. (I moved some typeGuido van Rossum2003-01-281-60/+69
| | | | | | checks to save_reduce(), which can also be called from a subclass.) Also tweaked some more comments.
* Got rid of the _quotes global. Used only once, and is trivial.Tim Peters2003-01-281-3/+1
|
* Add a few comments. Change the way the protocol is checked (it mustGuido van Rossum2003-01-281-2/+8
| | | | | | | be one of 0, 1 or 2). I should note that the previous checkin also added NEWOBJ support to the unpickler -- but there's nothing yet that generates this.
* Rename all variables 'object' to 'obj' to avoid conflicts with theGuido van Rossum2003-01-281-112/+113
| | | | | type 'object'. Also minor docstring tweakage, and rearranged a few lines in save().
* Don't memoize the empty tuple in protocol 0.Guido van Rossum2003-01-281-1/+2
|
* save_tuple(): So long as the charter is rewriting for clarity, the snakyTim Peters2003-01-281-21/+20
| | | | control flow had to be simplified.
* save_tuple(): I believe the new code for TUPLE{1,2,3} in proto 2 wasTim Peters2003-01-281-2/+5
| | | | | incorrect for recursive tuples. Tried to repair; seems to work OK, but there are no checked-in tests for this yet.
* OK, this is really the last one tonight!Guido van Rossum2003-01-281-1/+12
| | | | NEWFALSE and NEWTRUE.
* More protocol 2: TUPLE1, TUPLE2, TUPLE3.Guido van Rossum2003-01-281-11/+35
| | | | Also moved the special case for empty tuples from save() to save_tuple().
* save_inst(): Rewrote to have only one branch on self.bin. Also got ridTim Peters2003-01-281-16/+9
| | | | | of my recent XXX comment, taking a (what appears to be vanishingly small) chance and calling self.memoize() instead.
* First baby steps towards implementing protocol 2: PROTO, LONG1 and LONG4.Guido van Rossum2003-01-281-1/+88
|
* Fixed odd whitespace after "if", which I believe I introduced long ago.Tim Peters2003-01-281-1/+1
|
* save_int(): Fixed two new off-by-1 glitches.Tim Peters2003-01-281-2/+2
|
* Add a comment explaining that struct.pack() beats marshal.dumps(), butGuido van Rossum2003-01-281-0/+3
| | | | | marshal.loads() beats struct.unpack()! Possibly because the latter creates a one-tuple. :-(
* Got rid of mdumps; I timed it, and struct.pack("<i", x) is more thanGuido van Rossum2003-01-281-30/+26
| | | | | 40% faster than marshal.dumps(x)[1:]! (That's not counting the module attribute lookups, which can be avoided in either case.)
* save_tuple(): Minor rewriting, and added a comment about the subtletyTim Peters2003-01-281-8/+13
| | | | created by recursive tuples.
* load_appends(): replaced .append() loop with an .extend().Tim Peters2003-01-281-3/+1
|
* Comments.Tim Peters2003-01-281-1/+9
|
* save_dict(): Untangled most of the bin-vs-not-bin logic. Also usedTim Peters2003-01-281-15/+14
| | | | | iteritems() instead of materializing a (possibly giant) list of the items.
* save_list(): Rewrote, to untangle the proto 0 from the proto 1 cases.Tim Peters2003-01-281-15/+17
| | | | The code is much easier to follow now, and I bet it's faster too.
* save_list(): removed unused local "d".Tim Peters2003-01-281-2/+0
|
* save_list(): removed unused local "memo".Tim Peters2003-01-281-1/+0
|
* save_pers(): Switched the order of cases, to get rid of a "not", and toTim Peters2003-01-281-3/+3
| | | | | make the bin-vs-not-bin order consistent with what other routines try to do (they almost all handle the bin case first).
* Several routines appeared to inline the guts of memoize(), possibly forTim Peters2003-01-281-12/+9
| | | | | | some notion of low-level efficiency. Undid that, but left one routine alone: save_inst() claims it has a reason for not using memoize(). I don't understand that comment, so added an XXX comment there.
* save(): Fiddled the control flow to put the normal case where itTim Peters2003-01-281-44/+47
| | | | | belongs. This is a much smaller change than it may appear: the bulk of the function merely got unindented by one level.
* Added XXX about save()'s special-casing of tuples -- I don't get it.Tim Peters2003-01-281-0/+1
|
* save_bool(): simplified.Tim Peters2003-01-281-4/+1
|
* Repaired grammar in new comment.Tim Peters2003-01-281-1/+1
|
* clear_memo(): Repaired grammar in docstring.Tim Peters2003-01-281-3/+3
|
* Added one-line comments to the proto 2 opcodes.Tim Peters2003-01-281-14/+14
|
* Removed the new LONG2 opcode: it's extravagant. If LONG1 isn't enough,Tim Peters2003-01-281-7/+6
| | | | | | | | | | | | | | | | | | | then the embedded argument consumes at least 256 bytes. The difference between a 3-byte prefix (LONG2 + 2 bytes) and a 5-byte prefix (LONG4 + 4 bytes) is at worst less than 1%. Note that binary strings and binary Unicode strings also have only "size is 1 byte, or size is 4 bytes?" flavors, and I expect for the same reason. The only place a 2-byte thingie was used was in BININT2, where the 2 bytes make up the *entire* embedded argument (and now EXT2 also does this); that's a large savings over 4 bytes, because the total opcode+argument size is so small in the BININT2/EXT2 case. Removed the TAKEN_FROM_ARGUMENT "number of bytes" code, and bifurcated it into TAKEN_FROM_ARGUMENT1 and TAKEN_FROM_ARGUMENT4. Now there's enough info in ArgumentDescriptor objects to deduce the # of bytes consumed by each opcode. Rearranged the order in which proto2 opcodes are listed in pickle.py.
generated by cgit v0.12 at 2025-10-19 09:40:01 (GMT)