python-pickle 0.1.0 → 0.2.0

data/lib/python/pickle/protocol5.rb

@@ -7,14 +7,26 @@ module Python
   module Pickle
     class Protocol5 < Protocol4
 
-      # Opcodes for Pickle protocol 5.
+      # The `BYTEARRAY8` opcode.
       #
-      # @see https://peps.python.org/pep-0574/
-      OPCODES = Protocol4::OPCODES + Set[
-        150, # BYTEARRAY8
-        151, # NEXT_BUFFER
-        152, # READONLY_BUFFER
-      ]
+      # @since 0.2.0
+      #
+      # @see https://github.com/python/cpython/blob/v2.7/Lib/pickle.py#L193
+      BYTEARRAY8 = 150
+
+      # The `NEXT_BUFFER` opcode.
+      #
+      # @since 0.2.0
+      #
+      # @see https://github.com/python/cpython/blob/v2.7/Lib/pickle.py#L194
+      NEXT_BUFFER = 151
+
+      # The `READONLY_BUFFER` opcode.
+      #
+      # @since 0.2.0
+      #
+      # @see https://github.com/python/cpython/blob/v2.7/Lib/pickle.py#L195
+      READONLY_BUFFER = 152
 
       #
       # Reads an instruction from the pickle stream.
@@ -30,180 +42,86 @@ module Python
         #
         # Protocol 0 instructions
         #
-        when 40 # MARK
-          Instructions::MARK
-        when 46 # STOP
-          Instructions::STOP
-        when 48 # POP
-          Instructions::POP
-        when 49 # POP_MARK
-          Instructions::POP_MARK
-        when 50 # DUP
-          Instructions::DUP
-        when 70 # FLOAT
-          Instructions::Float.new(read_float)
-        when 73 # INT
-          Instructions::Int.new(read_int)
-        when 76 # LONG
-          Instructions::Long.new(read_long)
-        when 78 # NONE
-          Instructions::NONE
-        when 82 # REDUCE
-          Instructions::REDUCE
-        when 83 # STRING
-          Instructions::String.new(read_string)
-        when 86 # UNICODE
-          Instructions::String.new(read_unicode_string)
-        when 97 # APPEND
-          Instructions::APPEND
-        when 98 # BUILD
-          Instructions::BUILD
-        when 99 # GLOBAL
-          Instructions::Global.new(read_nl_string,read_nl_string)
-        when 100 # DICT
-          Instructions::DICT
-        when 103 # GET
-          Instructions::Get.new(read_int)
-        when 108 # LIST
-          Instructions::LIST
-        when 112 # PUT
-          Instructions::Put.new(read_int)
-        when 115 # SETITEM
-          Instructions::SETITEM
-        when 116 # TUPLE
-          Instructions::TUPLE
+        when MARK      then Instructions::MARK
+        when STOP      then Instructions::STOP
+        when POP       then Instructions::POP
+        when POP_MARK  then Instructions::POP_MARK
+        when DUP       then Instructions::DUP
+        when FLOAT     then read_float_instruction
+        when INT       then read_int_instruction
+        when LONG      then read_long_instruction
+        when NONE      then Instructions::NONE
+        when REDUCE    then Instructions::REDUCE
+        when STRING    then read_string_instruction
+        when UNICODE   then read_unicode_instruction
+        when APPEND    then Instructions::APPEND
+        when BUILD     then Instructions::BUILD
+        when GLOBAL    then read_global_instruction
+        when DICT      then Instructions::DICT
+        when GET       then read_get_instruction
+        when LIST      then Instructions::LIST
+        when PUT       then read_put_instruction
+        when SETITEM   then Instructions::SETITEM
+        when TUPLE     then Instructions::TUPLE
+        when INST      then read_inst_instruction
+        when OBJ       then Instructions::OBJ
+        when PERSID    then read_persid_instruction
+        when BINPERSID then Instructions::BINPERSID
         #
         # Protocol 1 instructions
         #
-        when 41  # EMPTY_TUPLE
-          Instructions::EMPTY_TUPLE
-        when 71  # BINFLOAT
-          Instructions::BinFloat.new(read_float64_be)
-        when 75  # BININT1
-          Instructions::BinInt1.new(read_uint8)
-        when 84  # BINSTRING
-          length = read_uint32_le
-          string = @io.read(length)
-
-          Instructions::BinString.new(length,string)
-        when 85  # SHORT_BINSTRING
-          length = read_uint8
-          string = @io.read(length)
-
-          Instructions::ShortBinString.new(length,string)
-        when 88  # BINUNICODE
-          length = read_uint32_le
-          string = @io.read(length).force_encoding(Encoding::UTF_8)
-
-          Instructions::BinUnicode.new(length,string)
-        when 93  # EMPTY_LIST
-          Instructions::EMPTY_LIST
-        when 101 # APPENDS
-          Instructions::APPENDS
-        when 104 # BINGET
-          Instructions::BinGet.new(read_uint8)
-        when 106 # LONG_BINGET
-          Instructions::LongBinGet.new(read_uint32_le)
-        when 113 # BINPUT
-          Instructions::BinPut.new(read_uint8)
-        when 117 # SETITEMS
-          Instructions::SETITEMS
-        when 125 # EMPTY_DICT
-          Instructions::EMPTY_DICT
+        when EMPTY_TUPLE     then Instructions::EMPTY_TUPLE
+        when BINFLOAT        then read_binfloat_instruction
+        when BININT1         then read_binint1_instruction
+        when BINSTRING       then read_binstring_instruction
+        when SHORT_BINSTRING then read_short_binstring_instruction
+        when BINUNICODE      then read_binunicode_instruction
+        when EMPTY_LIST      then Instructions::EMPTY_LIST
+        when APPENDS         then Instructions::APPENDS
+        when BINGET          then read_binget_instruction
+        when LONG_BINGET     then read_long_binget_instruction
+        when BINPUT          then read_binput_instruction
+        when SETITEMS        then Instructions::SETITEMS
+        when EMPTY_DICT      then Instructions::EMPTY_DICT
         #
         # Protocol 2 instructions
         #
-        when 128 # PROT
-          Instructions::Proto.new(read_uint8)
-        when 129 # NEWOBJ
-          Instructions::NEWOBJ
-        when 130 # EXT1
-          Instructions::Ext1.new(read_uint8)
-        when 131 # EXT2
-          Instructions::Ext2.new(read_uint16_le)
-        when 132 # EXT4
-          Instructions::Ext4.new(read_uint32_le)
-        when 133 # TUPLE1
-          Instructions::TUPLE1
-        when 134 # TUPLE2
-          Instructions::TUPLE2
-        when 135 # TUPLE3
-          Instructions::TUPLE3
-        when 136 # NEWTRUE
-          Instructions::NEWTRUE
-        when 137 # NEWFALSE
-          Instructions::NEWFALSE
-        when 138 # LONG1
-          length = read_uint8
-          long   = read_int_le(length)
-
-          Instructions::Long1.new(length,long)
-        when 139 # LONG4
-          length = read_uint32_le
-          long   = read_int_le(length)
-
-          Instructions::Long4.new(length,long)
+        when PROTO    then read_proto_instruction
+        when NEWOBJ   then Instructions::NEWOBJ
+        when EXT1     then read_ext1_instruction
+        when EXT2     then read_ext2_instruction
+        when EXT4     then read_ext4_instruction
+        when TUPLE1   then Instructions::TUPLE1
+        when TUPLE2   then Instructions::TUPLE2
+        when TUPLE3   then Instructions::TUPLE3
+        when NEWTRUE  then Instructions::NEWTRUE
+        when NEWFALSE then Instructions::NEWFALSE
+        when LONG1    then read_long1_instruction
+        when LONG4    then read_long4_instruction
         #
         # Protocol 3 instructions
         #
-        when 66 # BINBYTES
-          length = read_uint32_le
-          bytes  = @io.read(length)
-
-          Instructions::BinBytes.new(length,bytes)
-        when 67 # SHORT_BINBYTES
-          length = read_uint8
-          bytes  = @io.read(length)
-
-          Instructions::ShortBinBytes.new(length,bytes)
+        when BINBYTES       then read_binbytes_instruction
+        when SHORT_BINBYTES then read_short_binbytes_instruction
         #
         # Protocol 4 instructions
         #
-        when 140 # SHORT_BINUNICODE
-          length = read_uint8
-          string = read_utf8_string(length)
-
-          Instructions::ShortBinUnicode.new(length,string)
-        when 141 # BINUNICODE8
-          length = read_uint64_le
-          string = read_utf8_string(length)
-
-          Instructions::BinUnicode8.new(length,string)
-        when 142 # BINBYTES8
-          length = read_uint64_le
-          bytes  = @io.read(length)
-
-          Instructions::BinBytes8.new(length,bytes)
-        when 143 # EMPTY_SET
-          Instructions::EMPTY_SET
-        when 144 # ADDITEMS
-          Instructions::ADDITEMS
-        when 145 # FROZENSET
-          Instructions::FROZENSET
-        when 146 # NEWOBJ_EX
-          Instructions::NEWOBJ_EX
-        when 147 # STACK_GLOBAL
-          Instructions::STACK_GLOBAL
-        when 148 # MEMOIZE
-          Instructions::MEMOIZE
-        when 149 # FRAME
-          length = read_uint64_le
-
-          enter_frame(read_frame(length))
-
-          Instructions::Frame.new(length)
+        when SHORT_BINUNICODE then read_short_binunicode_instruction
+        when BINUNICODE8      then read_binunicode8_instruction
+        when BINBYTES8        then read_binbytes8_instruction
+        when EMPTY_SET        then Instructions::EMPTY_SET
+        when ADDITEMS         then Instructions::ADDITEMS
+        when FROZENSET        then Instructions::FROZENSET
+        when NEWOBJ_EX        then Instructions::NEWOBJ_EX
+        when STACK_GLOBAL     then Instructions::STACK_GLOBAL
+        when MEMOIZE          then Instructions::MEMOIZE
+        when FRAME            then read_frame_instruction
         #
         # Protocol 5 instructions.
         #
-        when 150 # BYTEARRAY8
-          length = read_uint64_le
-          bytes  = @io.read(length)
-
-          Instructions::ByteArray8.new(length,bytes)
-        when 151 # NEXT_BUFFER
-          Instructions::NEXT_BUFFER
-        when 152 # READONLY_BUFFER
-          Instructions::READONLY_BUFFER
+        when BYTEARRAY8      then read_bytearray8_instruction
+        when NEXT_BUFFER     then Instructions::NEXT_BUFFER
+        when READONLY_BUFFER then Instructions::READONLY_BUFFER
         else
           raise(InvalidFormat,"invalid opcode (#{opcode.inspect}) for protocol 5")
         end
@@ -213,6 +131,20 @@ module Python
         end
       end
 
+      #
+      # Reads a `BYTEARRAY8` instruction.
+      #
+      # @return [Instructions::ByteArray8]
+      #
+      # @since 0.2.0
+      #
+      def read_bytearray8_instruction
+        length = read_uint64_le
+        bytes  = @io.read(length)
+
+        Instructions::ByteArray8.new(length,bytes)
+      end
+
     end
   end
 end

data/lib/python/pickle/version.rb

@@ -1,6 +1,6 @@
 module Python
   module Pickle
     # python-pickle version
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
   end
 end

data/lib/python/pickle.rb

@@ -28,7 +28,7 @@ module Python
     # The default protocol version to use.
     #
     # @api public
-    DEFAULT_PROTCOL = 4
+    DEFAULT_PROTOCOL = 4
 
     # The highest protocol version supported.
     #
@@ -88,12 +88,25 @@ module Python
     #   The explicit protocol version to use. If `nil` the protocol version will
     #   be inferred by inspecting the first two bytes of the stream.
     #
+    # @param [Hash{Symbol => Object}] kwargs
+    #   Additional keyword arguments.
+    #
+    # @option kwargs [Hash{Integer => Object}] :extensions
+    #   A Hash of registered extension IDs and their Objects.
+    #
+    # @option kwargs [Hash{String => Hash{String => Class,Method}}] :constants
+    #   An optional mapping of custom Python constant names to Ruby classes
+    #   or methods.
+    #
+    # @option kwargs [Enumerable, nil] :buffers
+    #   An enumerable list of out-of-band buffers.
+    #
     # @api public
     #
-    def self.load(data,**kwargs)
+    def self.load(data, protocol: nil, **kwargs)
       deserializer = Deserializer.new(**kwargs)
 
-      parse(data) do |instruction|
+      parse(data, protocol: protocol) do |instruction|
         status, object = deserializer.execute(instruction)
 
         if status == :halt
@@ -110,11 +123,30 @@ module Python
     # @param [String] path
     #   The path of the file.
     #
+    # @param [Hash{Symbol => Object}] kwargs
+    #   Additional keyword arguments.
+    #
+    # @option kwargs [Hash{Integer => Object}] :extensions
+    #   A Hash of registered extension IDs and their Objects.
+    #
+    # @option kwargs [Hash{String => Hash{String => Class,Method}}] :constants
+    #   An optional mapping of custom Python constant names to Ruby classes
+    #   or methods.
+    #
+    # @option kwargs [Enumerable, nil] :buffers
+    #   An enumerable list of out-of-band buffers.
+    #
     # @return [Object]
     #   The deserialized object.
     #
     def self.load_file(path,**kwargs)
-      load(File.open(path,'rb'),**kwargs)
+      result = nil
+
+      File.open(path,'rb') do |file|
+        result = load(file,**kwargs)
+      end
+
+      return result
     end
 
     #
@@ -129,12 +161,12 @@ module Python
     # @param [Integer] protocol
     #   The desired Python Pickle protocol to use.
     #
+    # @note serializing is currently not supported.
+    #
     # @api public
     #
     def self.dump(object,output=nil, protocol: DEFAULT_PROTOCOL)
-      if (protocol < 0) || (protocol > HIGHEST_PROTOCOL)
-        raise(ArgumentError,"protocol must be between 0 or #{HIGHEST_PROTOCOL}, but was #{protocol.inspect}")
-      end
+      raise(NotImplementedError,"pickle serializing is currently not supported")
     end
 
     #
@@ -157,38 +189,38 @@ module Python
 
       begin
         case opcode
-        when 0x80 # PROTO (added in protocol 2)
+        when Protocol2::PROTO
           version = io.getbyte
           io.ungetbyte(version)
           return version
-        when 48,  # POP (protocol 0)
-             50,  # DUP (protocol 0)
-             70,  # FLOAT (protocol 0)
-             83,  # STRING (protocol 0)
-             86,  # UNICODE (protocol 0)
-             100, # DICT (protocol 0)
-             103, # GET (protocol 0)
-             108, # LIST (protocol 0)
-             112  # PUT (protocol 0)
+        when Protocol0::POP,
+             Protocol0::DUP,
+             Protocol0::FLOAT,
+             Protocol0::STRING,
+             Protocol0::UNICODE,
+             Protocol0::DICT,
+             Protocol0::GET,
+             Protocol0::LIST,
+             Protocol0::PUT
           0
-        when 41,  # EMPTY_TUPLE (protocol 1)
-             71,  # BINFLOAT (protocol 1)
-             75,  # BININT1 (protocol 1)
-             84,  # BINSTRING (protocol 1)
-             85,  # SHORT_BINSTRING (protocol 1)
-             88,  # BINUNICODE (protocol 1)
-             93,  # EMPTY_LIST (protocol 1)
-             101, # APPENDS (protocol 1)
-             113, # BINPUT (protocol 1)
-             117, # SETITEMS (protocol 1)
-             125  # EMPTY_DICT (protocol 1)
+        when Protocol1::EMPTY_TUPLE,
+             Protocol1::BINFLOAT,
+             Protocol1::BININT1,
+             Protocol1::BINSTRING,
+             Protocol1::SHORT_BINSTRING,
+             Protocol1::BINUNICODE,
+             Protocol1::EMPTY_LIST,
+             Protocol1::APPENDS,
+             Protocol1::BINPUT,
+             Protocol1::SETITEMS,
+             Protocol1::EMPTY_DICT
           1
-        when 46 # STOP
+        when Protocol0::STOP
           # if we've read all the way to the end of the stream and still cannot
           # find any protocol 0 or protocol 1 specific opcodes, assume protocol 0
           0
-        when 73, # INT  (identical in both protocol 0 and 1)
-             76  # LONG (identical in both protocol 0 and 1)
+        when Protocol0::INT, # identical in both protocol 0 and 1
+             Protocol0::LONG # identical in both protocol 0 and 1
           chars = io.gets
 
           begin
@@ -196,15 +228,15 @@ module Python
           ensure
             chars.each_byte.reverse_each { |b| io.ungetbyte(b) }
           end
-        when 40,  # MARK    (identical in both protocol 0 and 1)
-             78,  # NONE    (identical in both protocol 0 and 1)
-             82,  # REDUCE  (identical in both protocol 0 and 1)
-             97,  # APPEND  (identical in both protocol 0 and 1)
-             98,  # BUILD   (identical in both protocol 0 and 1)
-             115, # SETITEM (identical in both protocol 0 and 1)
-             116  # TUPLE   (identical in both protocol 0 and 1)
+        when Protocol0::MARK,    # identical in both protocol 0 and 1
+             Protocol0::NONE,    # identical in both protocol 0 and 1
+             Protocol0::REDUCE,  # identical in both protocol 0 and 1
+             Protocol0::APPEND,  # identical in both protocol 0 and 1
+             Protocol0::BUILD,   # identical in both protocol 0 and 1
+             Protocol0::SETITEM, # identical in both protocol 0 and 1
+             Protocol0::TUPLE    # identical in both protocol 0 and 1
           infer_protocol_version(io)
-        when 99 # GLOBAL
+        when Protocol0::GLOBAL
           first_nl_string  = io.gets
           second_nl_string = io.gets