Changed name of Binary type to Bytes.

braincore · braincore · commit 5949729a5309 · 2016-05-20T11:04:41.000-07:00
Test Plan: Updated tests.

Reviewers: qiming, krieb
diff --git a/babelapi/babel/tower.py b/babelapi/babel/tower.py
@@ -11,8 +11,8 @@
     DeprecationInfo,
 )
 from ..data_type import (
-    Binary,
     Boolean,
+    Bytes,
     CompositeType,
     DataType,
     Float32,
@@ -68,7 +68,7 @@ class Environment(dict):
 class TowerOfBabel(object):
 
     data_types = [
-        Binary,
+        Bytes,
         Boolean,
         Float32,
         Float64,
diff --git a/babelapi/data_type.py b/babelapi/data_type.py
@@ -134,15 +134,15 @@ def check_example(self, ex_field):
                               ex_field.lineno, ex_field.path)
 
 
-class Binary(PrimitiveType):
+class Bytes(PrimitiveType):
 
     def check(self, val):
         if not isinstance(val, str):
-            raise ValueError('%r is not valid binary (Python str)' % val)
+            raise ValueError('%r is not valid bytes' % val)
 
     def check_example(self, ex_field):
         if not isinstance(ex_field.value, bytes):
-            raise InvalidSpec("'%s' is not valid binary",
+            raise InvalidSpec("'%s' is not valid bytes",
                               ex_field.lineno, ex_field.path)
 
 
@@ -1405,8 +1405,8 @@ def get_underlying_type(data_type):
     return unwrap_nullable(data_type)
 
 
-def is_binary_type(data_type):
-    return isinstance(data_type, Binary)
+def is_bytes_type(data_type):
+    return isinstance(data_type, Bytes)
 def is_boolean_type(data_type):
     return isinstance(data_type, Boolean)
 def is_composite_type(data_type):
diff --git a/doc/generator_ref.rst b/doc/generator_ref.rst
@@ -264,7 +264,7 @@ default
     ========================== ============ ============
     Primitive                  Python 2.x   Python 3.x
     ========================== ============ ============
-    Binary                     str          bytes
+    Bytes                      str          bytes
     Boolean                    bool         bool
     Float{32,64}               float        float
     Int{32,64}, UInt{32,64}    long         int
diff --git a/doc/json_serializer.rst b/doc/json_serializer.rst
@@ -12,8 +12,8 @@ Primitive Types
 ========================== ====================================================
 Babel Primitive            JSON Representation
 ========================== ====================================================
-Binary                     String: Base64-encoded
 Boolean                    Boolean
+Bytes                      String: Base64-encoded
 Float{32,64}               Number
 Int{32,64}, UInt{32,64}    Number
 List                       Array
diff --git a/doc/lang_ref.rst b/doc/lang_ref.rst
@@ -106,7 +106,7 @@ table of all primitive types and the arguments they take:
 Type                    Arguments (**bold** are required  Notes
                         and positional)
 ======================= ================================= =====================
-Binary                  --                                An array of bytes.
+Bytes                   --                                An array of bytes.
 Boolean                 --
 Float{32,64}            * min_value
                         * max_value
@@ -152,7 +152,7 @@ Here are some more examples::
         y Int64
 
     struct Example
-        f1 Binary
+        f1 Bytes
         f2 Boolean
         f3 Float64(min_value=0)
         # List of primitive types
@@ -754,7 +754,7 @@ Type Reference::
 
 Primitives::
 
-    PrimitiveType ::= 'Binary' | 'Boolean' | 'Float32' | 'Float64' | 'Int32'
+    PrimitiveType ::= 'Bytes' | 'Boolean' | 'Float32' | 'Float64' | 'Int32'
                   | 'Int64' | 'UInt32' | 'UInt64' | 'String' | 'Timestamp'
 
 Basic::
diff --git a/doc/using_generator.rst b/doc/using_generator.rst
@@ -93,17 +93,17 @@ Primitive Types
 The following table shows the mapping between a Babel `primitive type
 <lang_ref.rst#primitive-types>`_ and its corresponding type in Python.
 
-========================== ============ =======================================
-Primitive                  Python 2.x   Notes
-========================== ============ =======================================
-Binary                     str
+========================== ============== =====================================
+Primitive                  Python 2.x / 3    Notes
+========================== ============== =====================================
+Bytes                      bytes
 Boolean                    bool
-Float{32,64}               float        long type within range is converted.
+Float{32,64}               float          long type within range is converted.
 Int{32,64}, UInt{32,64}    long
 List                       list
-String                     unicode      str type is converted to unicode.
+String                     unicode / str  str type is converted to unicode.
 Timestamp                  datetime
-========================== ============ =======================================
+========================== ============== =====================================
 
 Struct
 ------
diff --git a/generator/python/babel_serializers.py b/generator/python/babel_serializers.py
@@ -259,7 +259,7 @@ def _make_json_friendly(data_type, val):
         return None
     elif isinstance(data_type, bv.Timestamp):
         return val.strftime(data_type.format)
-    elif isinstance(data_type, bv.Binary):
+    elif isinstance(data_type, bv.Bytes):
         return base64.b64encode(val).decode('ascii')
     elif isinstance(data_type, bv.Integer) and isinstance(val, bool):
         # A bool is a subclass of an int so it passes Integer validation. But,
@@ -286,7 +286,7 @@ def json_decode(data_type, serialized_obj, strict=True, old_style=False):
 
     Returns:
         The returned object depends on the input data_type.
-            - Binary -> bytes
+            - Bytes -> bytes
             - Boolean -> bool
             - Float -> float
             - Integer -> long
@@ -612,11 +612,11 @@ def _make_babel_friendly(data_type, val, strict, validate):
             return datetime.datetime.strptime(val, data_type.format)
         except ValueError as e:
             raise bv.ValidationError(e.args[0])
-    elif isinstance(data_type, bv.Binary):
+    elif isinstance(data_type, bv.Bytes):
         try:
             return base64.b64decode(val)
         except TypeError:
-            raise bv.ValidationError('invalid base64-encoded binary')
+            raise bv.ValidationError('invalid base64-encoded bytes')
     elif isinstance(data_type, bv.Void):
         if strict and val is not None:
             raise bv.ValidationError("expected null, got value")
diff --git a/generator/python/babel_validators.py b/generator/python/babel_validators.py
@@ -24,6 +24,7 @@
 else:
     _binary_types = (bytes, buffer)
 
+
 class ValidationError(Exception):
     """Raised when a value doesn't pass validation by its validator."""
 
@@ -63,6 +64,7 @@ def __repr__(self):
         # Not a perfect repr, but includes the error location information.
         return 'ValidationError(%r)' % str(self)
 
+
 def generic_type_name(v):
     """Return a descriptive type name that isn't Python specific. For example,
     an int value will return 'integer' rather than 'int'."""
@@ -80,6 +82,7 @@ def generic_type_name(v):
     else:
         return type(v).__name__
 
+
 class Validator(object):
     """All primitive and composite data types should be a subclass of this."""
     __metaclass__ = ABCMeta
@@ -99,17 +102,20 @@ def has_default(self):
     def get_default(self):
         raise AssertionError('No default available.')
 
+
 class Primitive(Validator):
     """A basic type that is defined by Babel."""
     pass
 
+
 class Boolean(Primitive):
 
     def validate(self, val):
         if not isinstance(val, bool):
             raise ValidationError('%r is not a valid boolean' % val)
         return val
 
+
 class Integer(Primitive):
     """
     Do not use this class directly. Extend it and specify a 'minimum' and
@@ -150,22 +156,27 @@ def validate(self, val):
     def __repr__(self):
         return '%s()' % self.__class__.__name__
 
+
 class Int32(Integer):
     minimum = -2**31
     maximum = 2**31 - 1
 
+
 class UInt32(Integer):
     minimum = 0
     maximum = 2**32 - 1
 
+
 class Int64(Integer):
     minimum = -2**63
     maximum = 2**63 - 1
 
+
 class UInt64(Integer):
     minimum = 0
     maximum = 2**64 - 1
 
+
 class Real(Primitive):
     """
     Do not use this class directly. Extend it and optionally set a 'minimum'
@@ -231,14 +242,17 @@ def validate(self, val):
     def __repr__(self):
         return '%s()' % self.__class__.__name__
 
+
 class Float32(Real):
     # Maximum and minimums from the IEEE 754-1985 standard
     minimum = -3.40282 * 10**38
     maximum = 3.40282 * 10**38
 
+
 class Float64(Real):
     pass
 
+
 class String(Primitive):
     """Represents a unicode string."""
 
@@ -296,7 +310,8 @@ def validate(self, val):
                                   % (val, self.pattern))
         return val
 
-class Binary(Primitive):
+
+class Bytes(Primitive):
 
     def __init__(self, min_length=None, max_length=None):
         if min_length is not None:
@@ -315,7 +330,7 @@ def __init__(self, min_length=None, max_length=None):
 
     def validate(self, val):
         if not isinstance(val, _binary_types):
-            raise ValidationError("expected binary type, got %s"
+            raise ValidationError("expected bytes type, got %s"
                                   % generic_type_name(val))
         elif self.max_length is not None and len(val) > self.max_length:
             raise ValidationError("'%s' must have at most %d bytes, got %d"
@@ -325,6 +340,7 @@ def validate(self, val):
                                   % (val, self.min_length, len(val)))
         return val
 
+
 class Timestamp(Primitive):
     """Note that while a format is specified, it isn't used in validation
     since a native Python datetime object is preferred. The format, however,
@@ -446,6 +462,7 @@ def get_default(self):
         assert not self.definition._has_required_fields, 'No default available.'
         return self.definition()
 
+
 class StructTree(Struct):
     """Validator for structs with enumerated subtypes.
 
@@ -456,6 +473,7 @@ class StructTree(Struct):
     def __init__(self, definition):
         super(StructTree, self).__init__(definition)
 
+
 class Union(Composite):
 
     def __init__(self, definition):
@@ -498,6 +516,7 @@ def validate_type_only(self, val):
             raise ValidationError('expected type %s or subtype, got %s' %
                 (self.definition.__name__, generic_type_name(val)))
 
+
 class Void(Primitive):
 
     def validate(self, val):
@@ -511,6 +530,7 @@ def has_default(self):
     def get_default(self):
         return None
 
+
 class Nullable(Validator):
 
     def __init__(self, validator):
diff --git a/generator/python/python.babelg.py b/generator/python/python.babelg.py
@@ -10,8 +10,8 @@
 import shutil
 from babelapi.data_type import (
     get_underlying_type,
-    is_binary_type,
     is_boolean_type,
+    is_bytes_type,
     is_composite_type,
     is_float_type,
     is_integer_type,
@@ -164,8 +164,8 @@ def _python_type_mapping(self, ns, data_type):
         for documentation purposes."""
         if is_string_type(data_type):
             return 'str'
-        elif is_binary_type(data_type):
-            return 'str'
+        elif is_bytes_type(data_type):
+            return 'bytes'
         elif is_boolean_type(data_type):
             return 'bool'
         elif is_float_type(data_type):
diff --git a/generator/python/test_python_gen.py b/generator/python/test_python_gen.py
@@ -20,6 +20,7 @@
     json_decode,
 )
 
+
 class TestDropInModules(unittest.TestCase):
     """
     Tests the babel_serializers and babel_validators modules.
@@ -103,8 +104,8 @@ def test_float_validator(self):
         # Passes
         f32.validate(0)
 
-    def test_binary_validator(self):
-        b = bv.Binary(min_length=1, max_length=10)
+    def test_bytes_validator(self):
+        b = bv.Bytes(min_length=1, max_length=10)
         # Not a valid binary type
         self.assertRaises(bv.ValidationError, lambda: b.validate(u'asdf'))
         # Too short
@@ -195,7 +196,7 @@ def test_json_encoder(self):
         self.assertEqual(json_encode(bv.Timestamp('%a, %d %b %Y %H:%M:%S +0000'), now),
                          json.dumps(now.strftime(f)))
         b = b'\xff' * 5
-        self.assertEqual(json_encode(bv.Binary(), b),
+        self.assertEqual(json_encode(bv.Bytes(), b),
                          json.dumps(base64.b64encode(b).decode('ascii')))
         self.assertEqual(json_encode(bv.Nullable(bv.String()), None), json.dumps(None))
         self.assertEqual(json_encode(bv.Nullable(bv.String()), u'abc'), json.dumps('abc'))
@@ -339,11 +340,11 @@ def test_json_decoder(self):
                                      json.dumps(now.strftime(f))),
                          now)
         b = b'\xff' * 5
-        self.assertEqual(json_decode(bv.Binary(),
+        self.assertEqual(json_decode(bv.Bytes(),
                                      json.dumps(base64.b64encode(b).decode('ascii'))),
                          b)
         self.assertRaises(bv.ValidationError,
-                          lambda: json_decode(bv.Binary(), json.dumps(1)))
+                          lambda: json_decode(bv.Bytes(), json.dumps(1)))
         self.assertEqual(json_decode(bv.Nullable(bv.String()), json.dumps(None)), None)
         self.assertEqual(json_decode(bv.Nullable(bv.String()), json.dumps('abc')), 'abc')
 
@@ -521,7 +522,7 @@ def get_t(self):
     b Int64
 
 struct B extends A
-    c Binary
+    c Bytes
 
 struct C extends B
     d Float64
