AVRO-1788: Implement Python 2 API

lang/py3/avro/__init__.py

@@ -24,11 +24,11 @@
 import os
 
 
-def LoadResource(name):
+def load_resource(name):
   dir_path = os.path.dirname(__file__)
   rsrc_path = os.path.join(dir_path, name)
   with open(rsrc_path, 'r') as f:
     return f.read()
 
 
-VERSION = LoadResource('VERSION.txt').strip()
+VERSION = load_resource('VERSION.txt').strip()

lang/py3/avro/datafile.py

@@ -57,7 +57,7 @@
 SYNC_INTERVAL = 1000 * SYNC_SIZE
 
 # Schema of the container header:
-META_SCHEMA = schema.Parse("""
+META_SCHEMA = schema.parse("""
 {
   "type": "record", "name": "org.apache.avro.file.Header",
   "fields": [{
@@ -164,7 +164,7 @@ def __init__(
       # get schema used to write existing file
       schema_from_file = dfr.GetMeta('avro.schema').decode('utf-8')
       self.SetMeta('avro.schema', schema_from_file)
-      self.datum_writer.writer_schema = schema.Parse(schema_from_file)
+      self.datum_writer.writer_schema = schema.parse(schema_from_file)
 
       # seek to the end of the file and prepare for writing
       writer.seek(0, 2)
@@ -364,7 +364,7 @@ def __init__(self, reader, datum_reader):
     # get ready to read
     self._block_count = 0
     self.datum_reader.writer_schema = (
-        schema.Parse(self.GetMeta(SCHEMA_KEY).decode('utf-8')))
+        schema.parse(self.GetMeta(SCHEMA_KEY).decode('utf-8')))
 
   def __enter__(self):
     return self

lang/py3/avro/io.py

@@ -93,7 +93,7 @@ def __init__(self, fail_msg, writer_schema=None, reader_schema=None):
 # Validate
 
 
-def Validate(expected_schema, datum):
+def validate(expected_schema, datum):
   """Determines if a python datum is an instance of a schema.
 
   Args:
@@ -125,18 +125,18 @@ def Validate(expected_schema, datum):
     return datum in expected_schema.symbols
   elif schema_type == 'array':
     return (isinstance(datum, list)
-        and all(Validate(expected_schema.items, item) for item in datum))
+        and all(validate(expected_schema.items, item) for item in datum))
   elif schema_type == 'map':
     return (isinstance(datum, dict)
         and all(isinstance(key, str) for key in datum.keys())
-        and all(Validate(expected_schema.values, value)
+        and all(validate(expected_schema.values, value)
                 for value in datum.values()))
   elif schema_type in ['union', 'error_union']:
-    return any(Validate(union_branch, datum)
+    return any(validate(union_branch, datum)
                for union_branch in expected_schema.schemas)
   elif schema_type in ['record', 'error', 'request']:
     return (isinstance(datum, dict)
-        and all(Validate(field.type, datum.get(field.name))
+        and all(validate(field.type, datum.get(field.name))
                 for field in expected_schema.fields))
   else:
     raise AvroTypeException('Unknown Avro schema type: %r' % schema_type)
@@ -315,7 +315,7 @@ def write(self, datum):
     assert isinstance(datum, bytes), ('Expecting bytes, got %r' % datum)
     self.writer.write(datum)
 
-  def WriteByte(self, byte):
+  def write_byte(self, byte):
     self.writer.write(bytes((byte,)))
 
   def write_null(self, datum):
@@ -330,7 +330,7 @@ def write_boolean(self, datum):
     whose value is either 0 (false) or 1 (true).
     """
     # Python maps True to 1 and False to 0.
-    self.WriteByte(int(bool(datum)))
+    self.write_byte(int(bool(datum)))
 
   def write_int(self, datum):
     """
@@ -344,9 +344,9 @@ def write_long(self, datum):
     """
     datum = (datum << 1) ^ (datum >> 63)
     while (datum & ~0x7F) != 0:
-      self.WriteByte((datum & 0x7f) | 0x80)
+      self.write_byte((datum & 0x7f) | 0x80)
       datum >>= 7
-    self.WriteByte(datum)
+    self.write_byte(datum)
 
   def write_float(self, datum):
     """
@@ -355,10 +355,10 @@ def write_float(self, datum):
     Java's floatToIntBits and then encoded in little-endian format.
     """
     bits = STRUCT_INT.unpack(STRUCT_FLOAT.pack(datum))[0]
-    self.WriteByte((bits) & 0xFF)
-    self.WriteByte((bits >> 8) & 0xFF)
-    self.WriteByte((bits >> 16) & 0xFF)
-    self.WriteByte((bits >> 24) & 0xFF)
+    self.write_byte((bits) & 0xFF)
+    self.write_byte((bits >> 8) & 0xFF)
+    self.write_byte((bits >> 16) & 0xFF)
+    self.write_byte((bits >> 24) & 0xFF)
 
   def write_double(self, datum):
     """
@@ -367,14 +367,14 @@ def write_double(self, datum):
     Java's doubleToLongBits and then encoded in little-endian format.
     """
     bits = STRUCT_LONG.unpack(STRUCT_DOUBLE.pack(datum))[0]
-    self.WriteByte((bits) & 0xFF)
-    self.WriteByte((bits >> 8) & 0xFF)
-    self.WriteByte((bits >> 16) & 0xFF)
-    self.WriteByte((bits >> 24) & 0xFF)
-    self.WriteByte((bits >> 32) & 0xFF)
-    self.WriteByte((bits >> 40) & 0xFF)
-    self.WriteByte((bits >> 48) & 0xFF)
-    self.WriteByte((bits >> 56) & 0xFF)
+    self.write_byte((bits) & 0xFF)
+    self.write_byte((bits >> 8) & 0xFF)
+    self.write_byte((bits >> 16) & 0xFF)
+    self.write_byte((bits >> 24) & 0xFF)
+    self.write_byte((bits >> 32) & 0xFF)
+    self.write_byte((bits >> 40) & 0xFF)
+    self.write_byte((bits >> 48) & 0xFF)
+    self.write_byte((bits >> 56) & 0xFF)
 
   def write_bytes(self, datum):
     """
@@ -528,37 +528,37 @@ def read_data(self, writer_schema, reader_schema, decoder):
       fail_msg = "Cannot read unknown schema type: %s" % writer_schema.type
       raise schema.AvroException(fail_msg)
 
-  def skip_data(self, writer_schema, decoder):
-    if writer_schema.type == 'null':
+  def skip_data(self, writers_schema, decoder):
+    if writers_schema.type == 'null':
       return decoder.skip_null()
-    elif writer_schema.type == 'boolean':
+    elif writers_schema.type == 'boolean':
       return decoder.skip_boolean()
-    elif writer_schema.type == 'string':
+    elif writers_schema.type == 'string':
       return decoder.skip_utf8()
-    elif writer_schema.type == 'int':
+    elif writers_schema.type == 'int':
       return decoder.skip_int()
-    elif writer_schema.type == 'long':
+    elif writers_schema.type == 'long':
       return decoder.skip_long()
-    elif writer_schema.type == 'float':
+    elif writers_schema.type == 'float':
       return decoder.skip_float()
-    elif writer_schema.type == 'double':
+    elif writers_schema.type == 'double':
       return decoder.skip_double()
-    elif writer_schema.type == 'bytes':
+    elif writers_schema.type == 'bytes':
       return decoder.skip_bytes()
-    elif writer_schema.type == 'fixed':
-      return self.skip_fixed(writer_schema, decoder)
-    elif writer_schema.type == 'enum':
-      return self.skip_enum(writer_schema, decoder)
-    elif writer_schema.type == 'array':
-      return self.skip_array(writer_schema, decoder)
-    elif writer_schema.type == 'map':
-      return self.skip_map(writer_schema, decoder)
-    elif writer_schema.type in ['union', 'error_union']:
-      return self.skip_union(writer_schema, decoder)
-    elif writer_schema.type in ['record', 'error', 'request']:
-      return self.skip_record(writer_schema, decoder)
+    elif writers_schema.type == 'fixed':
+      return self.skip_fixed(writers_schema, decoder)
+    elif writers_schema.type == 'enum':
+      return self.skip_enum(writers_schema, decoder)
+    elif writers_schema.type == 'array':
+      return self.skip_array(writers_schema, decoder)
+    elif writers_schema.type == 'map':
+      return self.skip_map(writers_schema, decoder)
+    elif writers_schema.type in ['union', 'error_union']:
+      return self.skip_union(writers_schema, decoder)
+    elif writers_schema.type in ['record', 'error', 'request']:
+      return self.skip_record(writers_schema, decoder)
     else:
-      fail_msg = "Unknown schema type: %s" % writer_schema.type
+      fail_msg = "Unknown schema type: %s" % writers_schema.type
       raise schema.AvroException(fail_msg)
 
   def read_fixed(self, writer_schema, reader_schema, decoder):
@@ -805,7 +805,7 @@ def set_writer_schema(self, writer_schema):
 
   def write(self, datum, encoder):
     # validate datum
-    if not Validate(self.writer_schema, datum):
+    if not validate(self.writer_schema, datum):
       raise AvroTypeException(self.writer_schema, datum)
 
     self.write_data(self.writer_schema, datum, encoder)
@@ -911,7 +911,7 @@ def write_union(self, writer_schema, datum, encoder):
     # resolve union
     index_of_schema = -1
     for i, candidate_schema in enumerate(writer_schema.schemas):
-      if Validate(candidate_schema, datum):
+      if validate(candidate_schema, datum):
         index_of_schema = i
     if index_of_schema < 0: raise AvroTypeException(writer_schema, datum)