Make pickle version for python_memcache_serializer adjustable

It's unsafe to use the max pickle version when you are switching between
versions of python with different max versions.

Add a new function get_python_memcache_serializer_pickle_version that
returns a python_memcache_serializer with any pickle version.

pymemcache/serde.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from functools import partial
 import logging
 from io import BytesIO
 import six
@@ -30,16 +31,16 @@
 FLAG_COMPRESSED = 1 << 3  # unused, to main compatibility with python-memcached
 FLAG_TEXT = 1 << 4
 
-# Pickle protocol version (-1 for highest available to runtime)
+# Pickle protocol version (highest available to runtime)
 # Warning with `0`: If somewhere in your value lies a slotted object,
 # ie defines `__slots__`, even if you do not include it in your pickleable
 # state via `__getstate__`, python will complain with something like:
 #   TypeError: a class that defines __slots__ without defining __getstate__
 #   cannot be pickled
-PICKLE_VERSION = -1
+DEFAULT_PICKLE_VERSION = pickle.HIGHEST_PROTOCOL
 
 
-def python_memcache_serializer(key, value):
+def _python_memcache_serializer(key, value, pickle_version=None):
     flags = 0
     value_type = type(value)
 
@@ -63,13 +64,22 @@ def python_memcache_serializer(key, value):
     else:
         flags |= FLAG_PICKLE
         output = BytesIO()
-        pickler = pickle.Pickler(output, PICKLE_VERSION)
+        pickler = pickle.Pickler(output, pickle_version)
         pickler.dump(value)
         value = output.getvalue()
 
     return value, flags
 
 
+def get_python_memcache_serializer_pickle_version(pickle_version=None):
+    """Return a serializer using a specific pickle version"""
+    return partial(_python_memcache_serializer, pickle_version=pickle_version)
+
+
+python_memcache_serializer = partial(
+    _python_memcache_serializer, pickle_version=DEFAULT_PICKLE_VERSION)
+
+
 def python_memcache_deserializer(key, value, flags):
     if flags == 0:
         return value

pymemcache/test/test_serde.py

@@ -2,6 +2,7 @@
 from unittest import TestCase
 
 from pymemcache.serde import (python_memcache_serializer,
+                              get_python_memcache_serializer_pickle_version,
                               python_memcache_deserializer, FLAG_BYTES,
                               FLAG_PICKLE, FLAG_INTEGER, FLAG_LONG, FLAG_TEXT)
 import pytest
@@ -20,9 +21,10 @@ class CustomInt(int):
 
 @pytest.mark.unit()
 class TestSerde(TestCase):
+    serializer = python_memcache_serializer
 
     def check(self, value, expected_flags):
-        serialized, flags = python_memcache_serializer(b'key', value)
+        serialized, flags = self.serializer(b'key', value)
         assert flags == expected_flags
 
         # pymemcache stores values as byte strings, so we immediately the value
@@ -59,3 +61,18 @@ def test_pickleable(self):
     def test_subtype(self):
         # Subclass of a native type will be restored as the same type
         self.check(CustomInt(123123), FLAG_PICKLE)
+
+
+@pytest.mark.unit()
+class TestSerdePickleVersion0(TestCase):
+    serializer = get_python_memcache_serializer_pickle_version(pickle_version=0)
+
+
+@pytest.mark.unit()
+class TestSerdePickleVersion1(TestCase):
+    serializer = get_python_memcache_serializer_pickle_version(pickle_version=1)
+
+
+@pytest.mark.unit()
+class TestSerdePickleVersion2(TestCase):
+    serializer = get_python_memcache_serializer_pickle_version(pickle_version=2)