All marshaling is working by supported pythons (26, 27, 33, pypy).

timsavage · timsavage · commit 558910e80456 · 2014-03-21T00:33:05.000+11:00
Have taken the approach of replacing methods at module load time (using if six.PY2). Much of this has been required where the assumption has been made that strings are not unicode, this of course is not true of Python 3
diff --git a/cassandra/cqltypes.py b/cassandra/cqltypes.py
@@ -35,6 +35,7 @@
 
 if six.PY3:
     _number_types = frozenset((int, float))
+    long = int
 else:
     _number_types = frozenset((int, long, float))
 
@@ -217,7 +218,7 @@ def to_binary(cls, val):
         more information. This method differs in that if None is passed in,
         the result is the empty string.
         """
-        return six.binary_type() if val is None else cls.serialize(val)
+        return b'' if val is None else cls.serialize(val)
 
     @staticmethod
     def deserialize(byts):
@@ -278,7 +279,8 @@ def apply_parameters(cls, subtypes, names=None):
         if cls.num_subtypes != 'UNKNOWN' and len(subtypes) != cls.num_subtypes:
             raise ValueError("%s types require %d subtypes (%d given)"
                              % (cls.typename, cls.num_subtypes, len(subtypes)))
-        newname = cls.cass_parameterized_type_with(subtypes).encode('utf8')
+        # newname = cls.cass_parameterized_type_with(subtypes).encode('utf8')
+        newname = cls.cass_parameterized_type_with(subtypes)
         return type(newname, (cls,), {'subtypes': subtypes, 'cassname': cls.cassname})
 
     @classmethod
@@ -309,10 +311,16 @@ class _UnrecognizedType(_CassandraType):
     num_subtypes = 'UNKNOWN'
 
 
-def mkUnrecognizedType(casstypename):
-    return CassandraTypeType(casstypename.encode('utf8'),
-                             (_UnrecognizedType,),
-                             {'typename': "'%s'" % casstypename})
+if six.PY3:
+    def mkUnrecognizedType(casstypename):
+        return CassandraTypeType(casstypename,
+                                 (_UnrecognizedType,),
+                                 {'typename': "'%s'" % casstypename})
+else:
+    def mkUnrecognizedType(casstypename):
+        return CassandraTypeType(casstypename.encode('utf8'),
+                                 (_UnrecognizedType,),
+                                 {'typename': "'%s'" % casstypename})
 
 
 class BytesType(_CassandraType):
@@ -321,11 +329,11 @@ class BytesType(_CassandraType):
 
     @staticmethod
     def validate(val):
-        return buffer(val)
+        return bytearray(val)
 
     @staticmethod
     def serialize(val):
-        return str(val)
+        return six.binary_type(val)
 
 
 class DecimalType(_CassandraType):
@@ -386,9 +394,25 @@ def serialize(truth):
         return int8_pack(truth)
 
 
-class AsciiType(_CassandraType):
-    typename = 'ascii'
-    empty_binary_ok = True
+if six.PY2:
+    class AsciiType(_CassandraType):
+        typename = 'ascii'
+        empty_binary_ok = True
+else:
+    class AsciiType(_CassandraType):
+        typename = 'ascii'
+        empty_binary_ok = True
+
+        @staticmethod
+        def deserialize(byts):
+            return byts.decode('ascii')
+
+        @staticmethod
+        def serialize(var):
+            try:
+                return var.encode('ascii')
+            except UnicodeDecodeError:
+                return var
 
 
 class FloatType(_CassandraType):
@@ -683,7 +707,7 @@ def serialize_safe(cls, themap):
         buf = six.BytesIO()
         buf.write(uint16_pack(len(themap)))
         try:
-            items = themap.iteritems()
+            items = six.iteritems(themap)
         except AttributeError:
             raise TypeError("Got a non-map object for a map value")
         for key, val in items:
diff --git a/cassandra/encoder.py b/cassandra/encoder.py
@@ -8,16 +8,15 @@
 
 from cassandra.util import OrderedDict
 
-# if six.PY3:
-#     unicode = str
-#     long = int
+if six.PY3:
+    long = int
 
 
 def cql_quote(term):
-    if isinstance(term, unicode):
-        return "'%s'" % term.encode('utf8').replace("'", "''")
-    elif isinstance(term, (str, bool)):
+    if isinstance(term, (str, bool)):
         return "'%s'" % str(term).replace("'", "''")
+    elif isinstance(term, six.text_type):
+        return "'%s'" % term.encode('utf8').replace("'", "''")
     else:
         return str(term)
 
@@ -62,11 +61,10 @@ def cql_encode_sequence(val):
 
 
 def cql_encode_map_collection(val):
-    return '{ %s }' % ' , '.join(
-                                 '%s : %s' % (
-                                     cql_encode_all_types(k),
-                                     cql_encode_all_types(v))
-                                 for k, v in val.iteritems())
+    return '{ %s }' % ' , '.join('%s : %s' % (
+        cql_encode_all_types(k),
+        cql_encode_all_types(v)
+    ) for k, v in six.iteritems(val))
 
 
 def cql_encode_list_collection(val):
@@ -82,7 +80,6 @@ def cql_encode_all_types(val):
 
 
 cql_encoders = {
-    six.binary_type: cql_encode_bytes,
     float: cql_encode_object,
     bytearray: cql_encode_bytes,
     str: cql_encode_str,
@@ -101,13 +98,13 @@ def cql_encode_all_types(val):
 
 if six.PY2:
     cql_encoders.update({
-        buffer: cql_encode_bytes,
         unicode: cql_encode_unicode,
+        buffer: cql_encode_bytes,
         long: cql_encode_object,
         types.NoneType: cql_encode_none,
     })
 else:
     cql_encoders.update({
         memoryview: cql_encode_bytes,
-        None: cql_encode_none,
+        type(None): cql_encode_none,
     })
diff --git a/cassandra/marshal.py b/cassandra/marshal.py
@@ -1,3 +1,4 @@
+import six
 import struct
 
 
@@ -29,11 +30,18 @@ def _make_packer(format_string):
 header_unpack = header_struct.unpack
 
 
-def varint_unpack(term):
-    val = int(term.encode('hex'), 16)
-    if (ord(term[0]) & 128) != 0:
-        val = val - (1 << (len(term) * 8))
-    return val
+if six.PY3:
+    def varint_unpack(term):
+        val = int(''.join("%02x" % i for i in term), 16)
+        if (term[0] & 128) != 0:
+            val -= 1 << (len(term) * 8)
+        return val
+else:
+    def varint_unpack(term):
+        val = int(term.encode('hex'), 16)
+        if (ord(term[0]) & 128) != 0:
+            val = val - (1 << (len(term) * 8))
+        return val
 
 
 def bitlength(n):
@@ -44,19 +52,25 @@ def bitlength(n):
     return bitlen
 
 
+if six.PY3:
+    byte_val = int
+else:
+    byte_val = ord
+
+
 def varint_pack(big):
     pos = True
     if big == 0:
-        return '\x00'
+        return b'\x00'
     if big < 0:
-        bytelength = bitlength(abs(big) - 1) / 8 + 1
+        bytelength = bitlength(abs(big) - 1) // 8 + 1
         big = (1 << bytelength * 8) + big
         pos = False
-    revbytes = []
+    revbytes = bytearray()
     while big > 0:
-        revbytes.append(chr(big & 0xff))
+        revbytes.append(big & 0xff)
         big >>= 8
-    if pos and ord(revbytes[-1]) & 0x80:
-        revbytes.append('\x00')
+    if pos and revbytes[-1] & 0x80:
+        revbytes.append(0)
     revbytes.reverse()
-    return ''.join(revbytes)
+    return six.binary_type(revbytes)
diff --git a/cassandra/metadata.py b/cassandra/metadata.py
@@ -779,14 +779,18 @@ def _make_option_strings(self):
         return list(sorted(ret))
 
 
-def protect_name(name):
-    if isinstance(name, six.text_type):
-        name = name.encode('utf8')
-    return maybe_escape_name(name)
+if six.PY3:
+    def protect_name(name):
+        return maybe_escape_name(name)
+else:
+    def protect_name(name):
+        if isinstance(name, six.text_type):
+            name = name.encode('utf8')
+        return maybe_escape_name(name)
 
 
 def protect_names(names):
-    return map(protect_name, names)
+    return [protect_name(n) for n in names]
 
 
 def protect_value(value):
@@ -998,7 +1002,7 @@ def __hash__(self):
         return hash(self.value)
 
     def __repr__(self):
-        return "<%s: %r>" % (self.__class__.__name__, self.value)
+        return "<%s: %s>" % (self.__class__.__name__, self.value)
     __str__ = __repr__
 
 MIN_LONG = -(2 ** 63)
@@ -1017,7 +1021,7 @@ class Murmur3Token(Token):
     @classmethod
     def hash_fn(cls, key):
         if murmur3 is not None:
-            h = murmur3(key)
+            h = int(murmur3(key))
             return h if h != MIN_LONG else MAX_LONG
         else:
             raise NoMurmur3()
@@ -1034,6 +1038,8 @@ class MD5Token(Token):
 
     @classmethod
     def hash_fn(cls, key):
+        if isinstance(key, six.text_type):
+            key = key.encode('UTF-8')
         return abs(varint_unpack(md5(key).digest()))
 
     def __init__(self, token):
diff --git a/cassandra/policies.py b/cassandra/policies.py
@@ -2,6 +2,7 @@
 import logging
 from random import randint
 from threading import Lock
+import six
 
 from cassandra import ConsistencyLevel
 
@@ -250,7 +251,7 @@ def make_query_plan(self, working_keyspace=None, query=None):
         for host in islice(cycle(local_live), pos, pos + len(local_live)):
             yield host
 
-        for dc, current_dc_hosts in self._dc_live_hosts.iteritems():
+        for dc, current_dc_hosts in six.iteritems(self._dc_live_hosts):
             if dc == self.local_dc:
                 continue
 
diff --git a/cassandra/query.py b/cassandra/query.py
@@ -408,11 +408,9 @@ def __str__(self):
 
 def bind_params(query, params):
     if isinstance(params, dict):
-        return query % dict((k, cql_encoders.get(type(v), cql_encode_object)(v))
-                    for k, v in params.iteritems())
+        return query % dict((k, cql_encoders.get(type(v), cql_encode_object)(v)) for k, v in six.iteritems(params))
     else:
-        return query % tuple(cql_encoders.get(type(v), cql_encode_object)(v)
-                     for v in params)
+        return query % tuple(cql_encoders.get(type(v), cql_encode_object)(v) for v in params)
 
 
 class TraceUnavailable(Exception):
diff --git a/tests/unit/test_marshalling.py b/tests/unit/test_marshalling.py
diff --git a/tests/unit/test_metadata.py b/tests/unit/test_metadata.py
diff --git a/tests/unit/test_types.py b/tests/unit/test_types.py
