diff --git a/lang/py3/avro/__init__.py b/lang/py3/avro/__init__.py index 3e3222ff4e1..808c41e5384 100644 --- a/lang/py3/avro/__init__.py +++ b/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() diff --git a/lang/py3/avro/datafile.py b/lang/py3/avro/datafile.py index 2a22e57d140..45050f2d132 100644 --- a/lang/py3/avro/datafile.py +++ b/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 diff --git a/lang/py3/avro/io.py b/lang/py3/avro/io.py index b944904ee51..4af0b57d1d4 100644 --- a/lang/py3/avro/io.py +++ b/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) diff --git a/lang/py3/avro/ipc.py b/lang/py3/avro/ipc.py index 792f76432cc..789a4524d01 100644 --- a/lang/py3/avro/ipc.py +++ b/lang/py3/avro/ipc.py @@ -37,7 +37,7 @@ # ------------------------------------------------------------------------------ # Constants -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: @@ -45,22 +45,22 @@ def LoadResource(name): # Handshake schema is pulled in during build -HANDSHAKE_REQUEST_SCHEMA_JSON = LoadResource('HandshakeRequest.avsc') -HANDSHAKE_RESPONSE_SCHEMA_JSON = LoadResource('HandshakeResponse.avsc') +HANDSHAKE_REQUEST_SCHEMA_JSON = load_resource('HandshakeRequest.avsc') +HANDSHAKE_RESPONSE_SCHEMA_JSON = load_resource('HandshakeResponse.avsc') -HANDSHAKE_REQUEST_SCHEMA = schema.Parse(HANDSHAKE_REQUEST_SCHEMA_JSON) -HANDSHAKE_RESPONSE_SCHEMA = schema.Parse(HANDSHAKE_RESPONSE_SCHEMA_JSON) +HANDSHAKE_REQUEST_SCHEMA = schema.parse(HANDSHAKE_REQUEST_SCHEMA_JSON) +HANDSHAKE_RESPONSE_SCHEMA = schema.parse(HANDSHAKE_RESPONSE_SCHEMA_JSON) HANDSHAKE_REQUESTOR_WRITER = avro_io.DatumWriter(HANDSHAKE_REQUEST_SCHEMA) HANDSHAKE_REQUESTOR_READER = avro_io.DatumReader(HANDSHAKE_RESPONSE_SCHEMA) HANDSHAKE_RESPONDER_WRITER = avro_io.DatumWriter(HANDSHAKE_RESPONSE_SCHEMA) HANDSHAKE_RESPONDER_READER = avro_io.DatumReader(HANDSHAKE_REQUEST_SCHEMA) -META_SCHEMA = schema.Parse('{"type": "map", "values": "bytes"}') +META_SCHEMA = schema.parse('{"type": "map", "values": "bytes"}') META_WRITER = avro_io.DatumWriter(META_SCHEMA) META_READER = avro_io.DatumReader(META_SCHEMA) -SYSTEM_ERROR_SCHEMA = schema.Parse('["string"]') +SYSTEM_ERROR_SCHEMA = schema.parse('["string"]') AVRO_RPC_MIME = 'avro/binary' @@ -122,7 +122,7 @@ def transceiver(self): return self._transceiver @abc.abstractmethod - def _IssueRequest(self, call_request, message_name, request_datum): + def _issue_request(self, call_request, message_name, request_datum): """TODO: Document this method. Args: @@ -134,7 +134,7 @@ def _IssueRequest(self, call_request, message_name, request_datum): """ raise Error('Abstract method') - def Request(self, message_name, request_datum): + def request(self, message_name, request_datum): """Writes a request message and reads a response or error message. Args: @@ -146,14 +146,14 @@ def Request(self, message_name, request_datum): # build handshake and call request buffer_writer = io.BytesIO() buffer_encoder = avro_io.BinaryEncoder(buffer_writer) - self._WriteHandshakeRequest(buffer_encoder) - self._WriteCallRequest(message_name, request_datum, buffer_encoder) + self._write_handshake_request(buffer_encoder) + self._write_call_request(message_name, request_datum, buffer_encoder) # send the handshake and call request; block until call response call_request = buffer_writer.getvalue() - return self._IssueRequest(call_request, message_name, request_datum) + return self._issue_request(call_request, message_name, request_datum) - def _WriteHandshakeRequest(self, encoder): + def _write_handshake_request(self, encoder): """Emits the handshake request. Args: @@ -179,7 +179,7 @@ def _WriteHandshakeRequest(self, encoder): logger.info('Sending handshake request: %s', request_datum) HANDSHAKE_REQUESTOR_WRITER.write(request_datum, encoder) - def _WriteCallRequest(self, message_name, request_datum, encoder): + def _write_call_request(self, message_name, request_datum, encoder): """ The format of a call request is: * request metadata, a map with values of type bytes @@ -198,14 +198,14 @@ def _WriteCallRequest(self, message_name, request_datum, encoder): encoder.write_utf8(message.name) # message parameters - self._WriteRequest(message.request, request_datum, encoder) + self._write_request(message.request, request_datum, encoder) - def _WriteRequest(self, request_schema, request_datum, encoder): + def _write_request(self, request_schema, request_datum, encoder): logger.info('writing request: %s', request_datum) datum_writer = avro_io.DatumWriter(request_schema) datum_writer.write(request_datum, encoder) - def _ReadHandshakeResponse(self, decoder): + def _read_handshake_response(self, decoder): """Reads and processes the handshake response message. Args: @@ -226,7 +226,7 @@ def _ReadHandshakeResponse(self, decoder): elif match == 'CLIENT': # Client's side hash mismatch: self._remote_protocol = \ - protocol.Parse(handshake_response['serverProtocol']) + protocol.parse(handshake_response['serverProtocol']) self._remote_hash = handshake_response['serverHash'] self._send_protocol = False return True @@ -234,14 +234,14 @@ def _ReadHandshakeResponse(self, decoder): elif match == 'NONE': # Neither client nor server match: self._remote_protocol = \ - protocol.Parse(handshake_response['serverProtocol']) + protocol.parse(handshake_response['serverProtocol']) self._remote_hash = handshake_response['serverHash'] self._send_protocol = True return False else: raise schema.AvroException('handshake_response.match=%r' % match) - def _ReadCallResponse(self, message_name, decoder): + def _read_call_response(self, message_name, decoder): """Reads and processes a method call response. The format of a call response is: @@ -277,18 +277,18 @@ def _ReadCallResponse(self, message_name, decoder): if not decoder.read_boolean(): writer_schema = remote_message_schema.response reader_schema = local_message_schema.response - return self._ReadResponse(writer_schema, reader_schema, decoder) + return self._read_response(writer_schema, reader_schema, decoder) else: writer_schema = remote_message_schema.errors reader_schema = local_message_schema.errors - raise self._ReadError(writer_schema, reader_schema, decoder) + raise self._read_error(writer_schema, reader_schema, decoder) - def _ReadResponse(self, writer_schema, reader_schema, decoder): + def _read_response(self, writer_schema, reader_schema, decoder): datum_reader = avro_io.DatumReader(writer_schema, reader_schema) result = datum_reader.read(decoder) return result - def _ReadError(self, writer_schema, reader_schema, decoder): + def _read_error(self, writer_schema, reader_schema, decoder): datum_reader = avro_io.DatumReader(writer_schema, reader_schema) return AvroRemoteException(datum_reader.read(decoder)) @@ -296,16 +296,16 @@ def _ReadError(self, writer_schema, reader_schema, decoder): class Requestor(BaseRequestor): """Concrete requestor implementation.""" - def _IssueRequest(self, call_request, message_name, request_datum): - call_response = self.transceiver.Transceive(call_request) + def _issue_request(self, call_request, message_name, request_datum): + call_response = self.transceiver.transceive(call_request) # process the handshake and call response buffer_decoder = avro_io.BinaryDecoder(io.BytesIO(call_response)) - call_response_exists = self._ReadHandshakeResponse(buffer_decoder) + call_response_exists = self._read_handshake_response(buffer_decoder) if call_response_exists: - return self._ReadCallResponse(message_name, buffer_decoder) + return self._read_call_response(message_name, buffer_decoder) else: - return self.Request(message_name, request_datum) + return self.request(message_name, request_datum) # ------------------------------------------------------------------------------ @@ -332,7 +332,7 @@ def get_protocol_cache(self, hash): def set_protocol_cache(self, hash, protocol): self._protocol_cache[hash] = protocol - def Respond(self, call_request): + def respond(self, call_request): """Entry point to process one procedure call. Args: @@ -350,7 +350,7 @@ def Respond(self, call_request): response_metadata = {} try: - remote_protocol = self._ProcessHandshake(buffer_decoder, buffer_encoder) + remote_protocol = self._process_handshake(buffer_decoder, buffer_encoder) # handshake failure if remote_protocol is None: return buffer_writer.getvalue() @@ -371,12 +371,12 @@ def Respond(self, call_request): raise schema.AvroException(fail_msg) writer_schema = remote_message.request reader_schema = local_message.request - request = self._ReadRequest(writer_schema, reader_schema, buffer_decoder) + request = self._read_request(writer_schema, reader_schema, buffer_decoder) logger.info('Processing request: %r', request) # perform server logic try: - response = self.Invoke(local_message, request) + response = self.invoke(local_message, request) except AvroRemoteException as exn: error = exn except Exception as exn: @@ -387,19 +387,19 @@ def Respond(self, call_request): buffer_encoder.write_boolean(error is not None) if error is None: writer_schema = local_message.response - self._WriteResponse(writer_schema, response, buffer_encoder) + self._write_response(writer_schema, response, buffer_encoder) else: writer_schema = local_message.errors - self._WriteError(writer_schema, error, buffer_encoder) + self._write_error(writer_schema, error, buffer_encoder) except schema.AvroException as exn: error = AvroRemoteException(str(exn)) buffer_encoder = avro_io.BinaryEncoder(io.StringIO()) META_WRITER.write(response_metadata, buffer_encoder) buffer_encoder.write_boolean(True) - self._WriteError(SYSTEM_ERROR_SCHEMA, error, buffer_encoder) + self._write_error(SYSTEM_ERROR_SCHEMA, error, buffer_encoder) return buffer_writer.getvalue() - def _ProcessHandshake(self, decoder, encoder): + def _process_handshake(self, decoder, encoder): """Processes an RPC handshake. Args: @@ -416,7 +416,7 @@ def _ProcessHandshake(self, decoder, encoder): client_protocol = handshake_request.get('clientProtocol') remote_protocol = self.get_protocol_cache(client_hash) if remote_protocol is None and client_protocol is not None: - remote_protocol = protocol.Parse(client_protocol) + remote_protocol = protocol.parse(client_protocol) self.set_protocol_cache(client_hash, remote_protocol) # evaluate remote's guess of the local protocol @@ -443,7 +443,7 @@ def _ProcessHandshake(self, decoder, encoder): return remote_protocol @abc.abstractmethod - def Invoke(self, local_message, request): + def invoke(self, local_message, request): """Processes one procedure call. Args: @@ -456,15 +456,15 @@ def Invoke(self, local_message, request): """ raise Error('abtract method') - def _ReadRequest(self, writer_schema, reader_schema, decoder): + def _read_request(self, writer_schema, reader_schema, decoder): datum_reader = avro_io.DatumReader(writer_schema, reader_schema) return datum_reader.read(decoder) - def _WriteResponse(self, writer_schema, response_datum, encoder): + def _write_response(self, writer_schema, response_datum, encoder): datum_writer = avro_io.DatumWriter(writer_schema) datum_writer.write(response_datum, encoder) - def _WriteError(self, writer_schema, error_exception, encoder): + def _write_error(self, writer_schema, error_exception, encoder): datum_writer = avro_io.DatumWriter(writer_schema) datum_writer.write(str(error_exception), encoder) @@ -479,7 +479,7 @@ class FramedReader(object): def __init__(self, reader): self._reader = reader - def Read(self): + def read(self): """Reads one message from the configured reader. Returns: @@ -487,10 +487,10 @@ def Read(self): """ message = io.BytesIO() # Read and append frames until we encounter a 0-size frame: - while self._ReadFrame(message) > 0: pass + while self._read_frame(message) > 0: pass return message.getvalue() - def _ReadFrame(self, message): + def _read_frame(self, message): """Reads and appends one frame into the given message bytes. Args: @@ -499,7 +499,7 @@ def _ReadFrame(self, message): Size of the frame that was read. The empty frame (size 0) indicates the end of a message. """ - frame_size = self._ReadInt32() + frame_size = self._read_int32() remaining = frame_size while remaining > 0: data_bytes = self._reader.read(remaining) @@ -511,7 +511,7 @@ def _ReadFrame(self, message): remaining -= len(data_bytes) return frame_size - def _ReadInt32(self): + def _read_int32(self): encoded = self._reader.read(UINT32_BE.size) if len(encoded) != UINT32_BE.size: raise ConnectionClosedException('Invalid header: %r' % encoded) @@ -524,7 +524,7 @@ class FramedWriter(object): def __init__(self, writer): self._writer = writer - def Write(self, message): + def write(self, message): """Writes a message. Message is chunked into sequences of frames terminated by an empty frame. @@ -535,17 +535,17 @@ def Write(self, message): while len(message) > 0: chunk_size = max(BUFFER_SIZE, len(message)) chunk = message[:chunk_size] - self._WriteBuffer(chunk) + self._write_buffer(chunk) message = message[chunk_size:] # A message is always terminated by a zero-length buffer. - self._WriteUnsignedInt32(0) + self._write_unsigned_int32(0) - def _WriteBuffer(self, chunk): - self._WriteUnsignedInt32(len(chunk)) + def _write_buffer(self, chunk): + self._write_unsigned_int32(len(chunk)) self._writer.write(chunk) - def _WriteUnsignedInt32(self, uint32): + def _write_unsigned_int32(self, uint32): self._writer.write(UINT32_BE.pack(uint32)) @@ -559,7 +559,7 @@ def remote_name(self): pass @abc.abstractmethod - def ReadMessage(self): + def read_message(self): """Reads a single message from the channel. Blocks until a message can be read. @@ -570,7 +570,7 @@ def ReadMessage(self): pass @abc.abstractmethod - def WriteMessage(self, message): + def write_message(self, message): """Writes a message into the channel. Blocks until the message has been written. @@ -580,7 +580,7 @@ def WriteMessage(self, message): """ pass - def Transceive(self, request): + def transceive(self, request): """Processes a single request-reply interaction. Synchronous request-reply interaction. @@ -590,11 +590,11 @@ def Transceive(self, request): Returns: The reply message. """ - self.WriteMessage(request) - result = self.ReadMessage() + self.write_message(request) + result = self.read_message() return result - def Close(self): + def close(self): """Closes this transceiver.""" pass @@ -619,25 +619,25 @@ def __init__(self, host, port, req_resource='/'): def remote_name(self): return self._remote_name - def ReadMessage(self): + def read_message(self): response = self._conn.getresponse() response_reader = FramedReader(response) - framed_message = response_reader.Read() + framed_message = response_reader.read() response.read() # ensure we're ready for subsequent requests return framed_message - def WriteMessage(self, message): + def write_message(self, message): req_method = 'POST' req_headers = {'Content-Type': AVRO_RPC_MIME} bio = io.BytesIO() req_body_buffer = FramedWriter(bio) - req_body_buffer.Write(message) + req_body_buffer.write(message) req_body = bio.getvalue() self._conn.request(req_method, self._req_resource, req_body, req_headers) - def Close(self): + def close(self): self._conn.close() self._conn = None @@ -646,13 +646,13 @@ def Close(self): # Server Implementations -def _MakeHandlerClass(responder): +def _make_handler_class(responder): class AvroHTTPRequestHandler(http.server.BaseHTTPRequestHandler): def do_POST(self): reader = FramedReader(self.rfile) - call_request = reader.Read() + call_request = reader.read() logger.info('Serialized request: %r', call_request) - call_response = responder.Respond(call_request) + call_response = responder.respond(call_request) logger.info('Serialized response: %r', call_response) self.send_response(200) @@ -660,7 +660,7 @@ def do_POST(self): self.end_headers() framed_writer = FramedWriter(self.wfile) - framed_writer.Write(call_response) + framed_writer.write(call_response) self.wfile.flush() logger.info('Response sent') @@ -688,7 +688,7 @@ def __init__(self, interface, port, responder): """ super(AvroIpcHttpServer, self).__init__( server_address=(interface, port), - RequestHandlerClass=_MakeHandlerClass(responder), + RequestHandlerClass=_make_handler_class(responder), ) diff --git a/lang/py3/avro/protocol.py b/lang/py3/avro/protocol.py index 629d2fdc432..7436bd8cbee 100644 --- a/lang/py3/avro/protocol.py +++ b/lang/py3/avro/protocol.py @@ -54,8 +54,8 @@ class Protocol(object): """An application protocol.""" @staticmethod - def _ParseTypeDesc(type_desc, names): - type_schema = schema.SchemaFromJSONData(type_desc, names=names) + def _parse_type_desc(type_desc, names): + type_schema = schema.schema_from_JSON_data(type_desc, names=names) if type_schema.type not in VALID_TYPE_SCHEMA_TYPES: raise ProtocolParseException( 'Invalid type %r in protocol %r: ' @@ -64,7 +64,7 @@ def _ParseTypeDesc(type_desc, names): return type_schema @staticmethod - def _ParseMessageDesc(name, message_desc, names): + def _parse_message_desc(name, message_desc, names): """Parses a protocol message descriptor. Args: @@ -80,7 +80,7 @@ def _ParseMessageDesc(name, message_desc, names): if request_desc is None: raise ProtocolParseException( 'Invalid message descriptor with no "request": %r.' % message_desc) - request_schema = Message._ParseRequestFromJSONDesc( + request_schema = Message._parse_request_from_JSON_desc( request_desc=request_desc, names=names, ) @@ -89,14 +89,14 @@ def _ParseMessageDesc(name, message_desc, names): if response_desc is None: raise ProtocolParseException( 'Invalid message descriptor with no "response": %r.' % message_desc) - response_schema = Message._ParseResponseFromJSONDesc( + response_schema = Message._parse_response_from_JSON_desc( response_desc=response_desc, names=names, ) # Errors are optional: errors_desc = message_desc.get('errors', tuple()) - error_union_schema = Message._ParseErrorsFromJSONDesc( + error_union_schema = Message._parse_errors_from_JSON_desc( errors_desc=errors_desc, names=names, ) @@ -109,9 +109,9 @@ def _ParseMessageDesc(name, message_desc, names): ) @staticmethod - def _ParseMessageDescMap(message_desc_map, names): + def _parse_message_desc_map(message_desc_map, names): for name, message_desc in message_desc_map.items(): - yield Protocol._ParseMessageDesc( + yield Protocol._parse_message_desc( name=name, message_desc=message_desc, names=names, @@ -241,7 +241,7 @@ class Message(object): """A Protocol message.""" @staticmethod - def _ParseRequestFromJSONDesc(request_desc, names): + def _parse_request_from_JSON_desc(request_desc, names): """Parses the request descriptor of a protocol message. Args: @@ -251,7 +251,7 @@ def _ParseRequestFromJSONDesc(request_desc, names): Returns: The parsed request schema, as an unnamed record. """ - fields = schema.RecordSchema._MakeFieldList(request_desc, names=names) + fields = schema.RecordSchema._make_field_list(request_desc, names=names) return schema.RecordSchema( name=None, namespace=None, @@ -261,7 +261,7 @@ def _ParseRequestFromJSONDesc(request_desc, names): ) @staticmethod - def _ParseResponseFromJSONDesc(response_desc, names): + def _parse_response_from_JSON_desc(response_desc, names): """Parses the response descriptor of a protocol message. Args: @@ -270,10 +270,10 @@ def _ParseResponseFromJSONDesc(response_desc, names): Returns: The parsed response schema. """ - return schema.SchemaFromJSONData(response_desc, names=names) + return schema.schema_from_JSON_data(response_desc, names=names) @staticmethod - def _ParseErrorsFromJSONDesc(errors_desc, names): + def _parse_errors_from_JSON_desc(errors_desc, names): """Parses the errors descriptor of a protocol message. Args: @@ -288,7 +288,7 @@ def _ParseErrorsFromJSONDesc(errors_desc, names): 'type': schema.ERROR_UNION, 'declared_errors': errors_desc, } - return schema.SchemaFromJSONData(error_union_desc, names=names) + return schema.schema_from_JSON_data(error_union_desc, names=names) def __init__(self, name, request, response, errors=None): self._name = name @@ -338,7 +338,7 @@ def __eq__(self, that): # ------------------------------------------------------------------------------ -def ProtocolFromJSONData(json_data): +def protocol_from_JSON_data(json_data): """Builds an Avro Protocol from its JSON descriptor. Args: @@ -365,11 +365,11 @@ def ProtocolFromJSONData(json_data): type_desc_list = json_data.get('types', tuple()) types = tuple(map( - lambda desc: Protocol._ParseTypeDesc(desc, names=names), + lambda desc: Protocol._parse_type_desc(desc, names=names), type_desc_list)) message_desc_map = json_data.get('messages', dict()) - messages = tuple(Protocol._ParseMessageDescMap(message_desc_map, names=names)) + messages = tuple(Protocol._parse_message_desc_map(message_desc_map, names=names)) return Protocol( name=name, @@ -379,7 +379,7 @@ def ProtocolFromJSONData(json_data): ) -def Parse(json_string): +def parse(json_string): """Constructs a Protocol from its JSON descriptor in text form. Args: @@ -398,5 +398,5 @@ def Parse(json_string): 'Error message: %r.' % (json_string, exn)) - return ProtocolFromJSONData(json_data) + return protocol_from_JSON_data(json_data) diff --git a/lang/py3/avro/schema.py b/lang/py3/avro/schema.py index 7ed3b541b5c..4f901fcbe72 100644 --- a/lang/py3/avro/schema.py +++ b/lang/py3/avro/schema.py @@ -260,7 +260,7 @@ def props(self): @property def other_props(self): """Returns: the dictionary of non-reserved properties.""" - return dict(FilterKeysOut(items=self._props, keys=SCHEMA_RESERVED_PROPS)) + return dict(filter_keys_out(items=self._props, keys=SCHEMA_RESERVED_PROPS)) def __str__(self): """Returns: the JSON representation of this schema.""" @@ -375,7 +375,7 @@ def default_namespace(self): """Returns: the default namespace, if any, or None.""" return self._default_namespace - def NewWithDefaultNamespace(self, namespace): + def new_with_default_namespace(self, namespace): """Creates a new name tracker from this tracker, but with a new default ns. Args: @@ -385,7 +385,7 @@ def NewWithDefaultNamespace(self, namespace): """ return Names(names=self._names, default_namespace=namespace) - def GetName(self, name, namespace=None): + def _get_name(self, name, namespace=None): """Resolves the Avro name according to this name tracker's state. Args: @@ -398,14 +398,14 @@ def GetName(self, name, namespace=None): return Name(name=name, namespace=namespace) def has_name(self, name, namespace=None): - avro_name = self.GetName(name=name, namespace=namespace) + avro_name = self._get_name(name=name, namespace=namespace) return avro_name.fullname in self._names def get_name(self, name, namespace=None): - avro_name = self.GetName(name=name, namespace=namespace) + avro_name = self._get_name(name=name, namespace=namespace) return self._names.get(avro_name.fullname, None) - def GetSchema(self, name, namespace=None): + def get_schema(self, name, namespace=None): """Resolves an Avro schema by name. Args: @@ -414,7 +414,7 @@ def GetSchema(self, name, namespace=None): Returns: The schema with the specified name, if any, or None. """ - avro_name = self.GetName(name=name, namespace=namespace) + avro_name = self._get_name(name=name, namespace=namespace) return self._names.get(avro_name.fullname, None) def prune_namespace(self, properties): @@ -435,7 +435,7 @@ def prune_namespace(self, properties): del(prunable['namespace']) return prunable - def Register(self, schema): + def register(self, schema): """Registers a new named schema in this tracker. Args: @@ -479,11 +479,11 @@ def __init__( other_props: Optional map of additional properties of the schema. """ assert (type in NAMED_TYPES), ('Invalid named type: %r' % type) - self._avro_name = names.GetName(name=name, namespace=namespace) + self._avro_name = names._get_name(name=name, namespace=namespace) super(NamedSchema, self).__init__(type, other_props) - names.Register(self) + names.register(self) self._props['name'] = self.name if self.namespace: @@ -617,7 +617,7 @@ def props(self): @property def other_props(self): - return FilterKeysOut(items=self._props, keys=FIELD_RESERVED_PROPS) + return filter_keys_out(items=self._props, keys=FIELD_RESERVED_PROPS) def __str__(self): return json.dumps(self.to_json()) @@ -943,7 +943,7 @@ class RecordSchema(NamedSchema): """Schema of a record.""" @staticmethod - def _MakeField(index, field_desc, names): + def _make_field(index, field_desc, names): """Builds field schemas from a list of field JSON descriptors. Args: @@ -953,12 +953,12 @@ def _MakeField(index, field_desc, names): Return: The field schema. """ - field_schema = SchemaFromJSONData( + field_schema = schema_from_JSON_data( json_data=field_desc['type'], names=names, ) other_props = ( - dict(FilterKeysOut(items=field_desc, keys=FIELD_RESERVED_PROPS))) + dict(filter_keys_out(items=field_desc, keys=FIELD_RESERVED_PROPS))) return Field( type=field_schema, name=field_desc['name'], @@ -972,7 +972,7 @@ def _MakeField(index, field_desc, names): ) @staticmethod - def _MakeFieldList(field_desc_list, names): + def _make_field_list(field_desc_list, names): """Builds field schemas from a list of field JSON descriptors. Guarantees field name unicity. @@ -984,10 +984,10 @@ def _MakeFieldList(field_desc_list, names): Field schemas. """ for index, field_desc in enumerate(field_desc_list): - yield RecordSchema._MakeField(index, field_desc, names) + yield RecordSchema._make_field(index, field_desc, names) @staticmethod - def _MakeFieldMap(fields): + def _make_field_map(fields): """Builds the field map. Guarantees field name unicity. @@ -1052,8 +1052,8 @@ def __init__( 'Invalid record type: %r.' % record_type) if record_type in [RECORD, ERROR]: - avro_name = names.GetName(name=name, namespace=namespace) - nested_names = names.NewWithDefaultNamespace(namespace=avro_name.namespace) + avro_name = names._get_name(name=name, namespace=namespace) + nested_names = names.new_with_default_namespace(namespace=avro_name.namespace) elif record_type == REQUEST: # Protocol request has no name: no need to change default namespace: nested_names = names @@ -1064,7 +1064,7 @@ def __init__( assert (make_fields is None) self._fields = tuple(fields) - self._field_map = RecordSchema._MakeFieldMap(self._fields) + self._field_map = RecordSchema._make_field_map(self._fields) self._props['fields'] = fields if doc is not None: @@ -1105,7 +1105,7 @@ def __eq__(self, that): # Module functions -def FilterKeysOut(items, keys): +def filter_keys_out(items, keys): """Filters a collection of (key, value) items. Exclude any item whose key belongs to keys. @@ -1124,12 +1124,12 @@ def FilterKeysOut(items, keys): # ------------------------------------------------------------------------------ -def _SchemaFromJSONString(json_string, names): +def _schema_from_JSON_string(json_string, names): if json_string in PRIMITIVE_TYPES: return PrimitiveSchema(type=json_string) else: # Look for a known named schema: - schema = names.GetSchema(name=json_string) + schema = names.get_schema(name=json_string) if schema is None: raise SchemaParseException( 'Unknown named schema %r, known names: %r.' @@ -1137,20 +1137,20 @@ def _SchemaFromJSONString(json_string, names): return schema -def _SchemaFromJSONArray(json_array, names): +def _schema_from_JSON_array(json_array, names): def MakeSchema(desc): - return SchemaFromJSONData(json_data=desc, names=names) + return schema_from_JSON_data(json_data=desc, names=names) return UnionSchema(map(MakeSchema, json_array)) -def _SchemaFromJSONObject(json_object, names): +def _schema_from_JSON_object(json_object, names): type = json_object.get('type') if type is None: raise SchemaParseException( 'Avro schema JSON descriptor has no "type" property: %r' % json_object) other_props = dict( - FilterKeysOut(items=json_object, keys=SCHEMA_RESERVED_PROPS)) + filter_keys_out(items=json_object, keys=SCHEMA_RESERVED_PROPS)) if type in PRIMITIVE_TYPES: # FIXME should not ignore other properties @@ -1170,13 +1170,13 @@ def _SchemaFromJSONObject(json_object, names): elif type in [RECORD, ERROR]: field_desc_list = json_object.get('fields', ()) - def MakeFields(names): - return tuple(RecordSchema._MakeFieldList(field_desc_list, names)) + def make_fields(names): + return tuple(RecordSchema._make_field_list(field_desc_list, names)) return RecordSchema( name=name, namespace=namespace, - make_fields=MakeFields, + make_fields=make_fields, names=names, record_type=type, doc=json_object.get('doc'), @@ -1195,7 +1195,7 @@ def MakeFields(names): 'Invalid array schema descriptor with no "items" : %r.' % json_object) return ArraySchema( - items=SchemaFromJSONData(items_desc, names), + items=schema_from_JSON_data(items_desc, names), other_props=other_props, ) @@ -1206,7 +1206,7 @@ def MakeFields(names): 'Invalid map schema descriptor with no "values" : %r.' % json_object) return MapSchema( - values=SchemaFromJSONData(values_desc, names=names), + values=schema_from_JSON_data(values_desc, names=names), other_props=other_props, ) @@ -1214,7 +1214,7 @@ def MakeFields(names): error_desc_list = json_object.get('declared_errors') assert (error_desc_list is not None) error_schemas = map( - lambda desc: SchemaFromJSONData(desc, names=names), + lambda desc: schema_from_JSON_data(desc, names=names), error_desc_list) return ErrorUnionSchema(schemas=error_schemas) @@ -1227,13 +1227,13 @@ def MakeFields(names): # Parsers for the JSON data types: _JSONDataParserTypeMap = { - str: _SchemaFromJSONString, - list: _SchemaFromJSONArray, - dict: _SchemaFromJSONObject, + str: _schema_from_JSON_string, + list: _schema_from_JSON_array, + dict: _schema_from_JSON_object, } -def SchemaFromJSONData(json_data, names=None): +def schema_from_JSON_data(json_data, names=None): """Builds an Avro Schema from its JSON descriptor. Args: @@ -1258,7 +1258,7 @@ def SchemaFromJSONData(json_data, names=None): # ------------------------------------------------------------------------------ -def Parse(json_string): +def parse(json_string): """Constructs a Schema from its JSON descriptor in text form. Args: @@ -1281,4 +1281,4 @@ def Parse(json_string): names = Names() # construct the Avro Schema object - return SchemaFromJSONData(json_data, names) + return schema_from_JSON_data(json_data, names) diff --git a/lang/py3/avro/tests/test_datafile.py b/lang/py3/avro/tests/test_datafile.py index 044afcbdc9f..9fd3e5e7a43 100644 --- a/lang/py3/avro/tests/test_datafile.py +++ b/lang/py3/avro/tests/test_datafile.py @@ -136,7 +136,7 @@ def testRoundTrip(self): logging.debug('Creating data file %r', file_path) with open(file_path, 'wb') as writer: datum_writer = io.DatumWriter() - schema_object = schema.Parse(writer_schema) + schema_object = schema.parse(writer_schema) with datafile.DataFileWriter( writer=writer, datum_writer=datum_writer, @@ -185,7 +185,7 @@ def testAppend(self): logging.debug('Creating data file %r', file_path) with open(file_path, 'wb') as writer: datum_writer = io.DatumWriter() - schema_object = schema.Parse(writer_schema) + schema_object = schema.parse(writer_schema) with datafile.DataFileWriter( writer=writer, datum_writer=datum_writer, @@ -231,7 +231,7 @@ def testContextManager(self): with open(file_path, 'wb') as writer: datum_writer = io.DatumWriter() sample_schema, sample_datum = SCHEMAS_TO_VALIDATE[1] - schema_object = schema.Parse(sample_schema) + schema_object = schema.parse(sample_schema) with datafile.DataFileWriter(writer, datum_writer, schema_object) as dfw: dfw.append(sample_datum) self.assertTrue(writer.closed) @@ -252,7 +252,7 @@ def testMetadata(self): with open(file_path, 'wb') as writer: datum_writer = io.DatumWriter() sample_schema, sample_datum = SCHEMAS_TO_VALIDATE[1] - schema_object = schema.Parse(sample_schema) + schema_object = schema.parse(sample_schema) with datafile.DataFileWriter(writer, datum_writer, schema_object) as dfw: dfw.SetMeta('test.string', 'foo') dfw.SetMeta('test.number', '1') diff --git a/lang/py3/avro/tests/test_datafile_interop.py b/lang/py3/avro/tests/test_datafile_interop.py index 93212c88d56..358a09fc823 100644 --- a/lang/py3/avro/tests/test_datafile_interop.py +++ b/lang/py3/avro/tests/test_datafile_interop.py @@ -33,7 +33,7 @@ def GetInteropSchema(): schema_json_path = os.path.join(test_dir, 'interop.avsc') with open(schema_json_path, 'r') as f: schema_json = f.read() - return schema.Parse(schema_json) + return schema.parse(schema_json) INTEROP_SCHEMA = GetInteropSchema() diff --git a/lang/py3/avro/tests/test_io.py b/lang/py3/avro/tests/test_io.py index 8349ce5c7e0..9188d804e2a 100644 --- a/lang/py3/avro/tests/test_io.py +++ b/lang/py3/avro/tests/test_io.py @@ -98,7 +98,7 @@ '{"A": 5}', {'A': 5}), ) -LONG_RECORD_SCHEMA = schema.Parse(""" +LONG_RECORD_SCHEMA = schema.parse(""" { "type": "record", "name": "Test", @@ -150,7 +150,7 @@ def check_binary_encoding(number_type): logging.debug('Datum: %d', datum) logging.debug('Correct Encoding: %s', hex_encoding) - writer_schema = schema.Parse('"%s"' % number_type.lower()) + writer_schema = schema.parse('"%s"' % number_type.lower()) writer, encoder, datum_writer = write_datum(datum, writer_schema) writer.seek(0) hex_val = avro_hexlify(writer) @@ -168,7 +168,7 @@ def check_skip_number(number_type): logging.debug('Value to Skip: %d', value_to_skip) # write the value to skip and a known value - writer_schema = schema.Parse('"%s"' % number_type.lower()) + writer_schema = schema.parse('"%s"' % number_type.lower()) writer, encoder, datum_writer = write_datum(value_to_skip, writer_schema) datum_writer.write(VALUE_TO_READ, encoder) @@ -181,7 +181,7 @@ def check_skip_number(number_type): datum_reader = avro_io.DatumReader(writer_schema) read_value = datum_reader.read(decoder) - logging.debug('Read Value: %d', read_value) + logging.debug('read Value: %d', read_value) if read_value == VALUE_TO_READ: correct += 1 return correct @@ -199,7 +199,7 @@ def testValidate(self): for example_schema, datum in SCHEMAS_TO_VALIDATE: logging.debug('Schema: %r', example_schema) logging.debug('Datum: %r', datum) - validated = avro_io.Validate(schema.Parse(example_schema), datum) + validated = avro_io.validate(schema.parse(example_schema), datum) logging.debug('Valid: %s', validated) if validated: passed += 1 self.assertEqual(passed, len(SCHEMAS_TO_VALIDATE)) @@ -210,7 +210,7 @@ def testRoundTrip(self): logging.debug('Schema: %s', example_schema) logging.debug('Datum: %s', datum) - writer_schema = schema.Parse(example_schema) + writer_schema = schema.parse(example_schema) writer, encoder, datum_writer = write_datum(datum, writer_schema) round_trip_datum = read_datum(writer, writer_schema) @@ -248,10 +248,10 @@ def testSchemaPromotion(self): promotable_schemas = ['"int"', '"long"', '"float"', '"double"'] incorrect = 0 for i, ws in enumerate(promotable_schemas): - writer_schema = schema.Parse(ws) + writer_schema = schema.parse(ws) datum_to_write = 219 for rs in promotable_schemas[i + 1:]: - reader_schema = schema.Parse(rs) + reader_schema = schema.parse(rs) writer, enc, dw = write_datum(datum_to_write, writer_schema) datum_read = read_datum(writer, writer_schema, reader_schema) logging.debug('Writer: %s Reader: %s', writer_schema, reader_schema) @@ -260,12 +260,12 @@ def testSchemaPromotion(self): self.assertEqual(incorrect, 0) def testUnknownSymbol(self): - writer_schema = schema.Parse("""\ + writer_schema = schema.parse("""\ {"type": "enum", "name": "Test", "symbols": ["FOO", "BAR"]}""") datum_to_write = 'FOO' - reader_schema = schema.Parse("""\ + reader_schema = schema.parse("""\ {"type": "enum", "name": "Test", "symbols": ["BAR", "BAZ"]}""") @@ -281,7 +281,7 @@ def testDefaultValue(self): correct = 0 for field_type, default_json, default_datum in DEFAULT_VALUE_EXAMPLES: - reader_schema = schema.Parse("""\ + reader_schema = schema.parse("""\ {"type": "record", "name": "Test", "fields": [{"name": "H", "type": %s, "default": %s}]} """ % (field_type, default_json)) @@ -297,7 +297,7 @@ def testNoDefaultValue(self): writer_schema = LONG_RECORD_SCHEMA datum_to_write = LONG_RECORD_DATUM - reader_schema = schema.Parse("""\ + reader_schema = schema.parse("""\ {"type": "record", "name": "Test", "fields": [{"name": "H", "type": "int"}]}""") @@ -311,7 +311,7 @@ def testProjection(self): writer_schema = LONG_RECORD_SCHEMA datum_to_write = LONG_RECORD_DATUM - reader_schema = schema.Parse("""\ + reader_schema = schema.parse("""\ {"type": "record", "name": "Test", "fields": [{"name": "E", "type": "int"}, {"name": "F", "type": "int"}]}""") @@ -326,7 +326,7 @@ def testFieldOrder(self): writer_schema = LONG_RECORD_SCHEMA datum_to_write = LONG_RECORD_DATUM - reader_schema = schema.Parse("""\ + reader_schema = schema.parse("""\ {"type": "record", "name": "Test", "fields": [{"name": "F", "type": "int"}, {"name": "E", "type": "int"}]}""") @@ -338,7 +338,7 @@ def testFieldOrder(self): self.assertEqual(datum_to_read, datum_read) def testTypeException(self): - writer_schema = schema.Parse("""\ + writer_schema = schema.parse("""\ {"type": "record", "name": "Test", "fields": [{"name": "F", "type": "int"}, {"name": "E", "type": "int"}]}""") diff --git a/lang/py3/avro/tests/test_ipc.py b/lang/py3/avro/tests/test_ipc.py index aa480b8395f..d0c10fd6d1a 100644 --- a/lang/py3/avro/tests/test_ipc.py +++ b/lang/py3/avro/tests/test_ipc.py @@ -77,7 +77,7 @@ def NowMS(): """ -ECHO_PROTOCOL = protocol.Parse(ECHO_PROTOCOL_JSON) +ECHO_PROTOCOL = protocol.parse(ECHO_PROTOCOL_JSON) class EchoResponder(ipc.Responder): @@ -86,7 +86,7 @@ def __init__(self): local_protocol=ECHO_PROTOCOL, ) - def Invoke(self, message, request): + def invoke(self, message, request): logging.info('Message: %s', message) logging.info('Request: %s', request) ping = request['ping'] @@ -136,19 +136,19 @@ def testEchoService(self): local_protocol=ECHO_PROTOCOL, transceiver=transceiver, ) - response = requestor.Request( + response = requestor.request( message_name='ping', request_datum={'ping': {'timestamp': 31415, 'text': 'hello ping'}}, ) logging.info('Received echo response: %s', response) - response = requestor.Request( + response = requestor.request( message_name='ping', request_datum={'ping': {'timestamp': 123456, 'text': 'hello again'}}, ) logging.info('Received echo response: %s', response) - transceiver.Close() + transceiver.close() finally: self.StopEchoServer() diff --git a/lang/py3/avro/tests/test_protocol.py b/lang/py3/avro/tests/test_protocol.py index db6f57e06cf..06c90c8458f 100644 --- a/lang/py3/avro/tests/test_protocol.py +++ b/lang/py3/avro/tests/test_protocol.py @@ -407,7 +407,7 @@ def testParse(self): 'Parsing protocol #%d:\n%s', iexample, example.protocol_string) try: - parsed = protocol.Parse(example.protocol_string) + parsed = protocol.parse(example.protocol_string) if example.valid: correct += 1 else: @@ -428,17 +428,17 @@ def testParse(self): self.assertEqual( correct, len(EXAMPLES), - 'Parse behavior correct on %d out of %d protocols.' + 'parse behavior correct on %d out of %d protocols.' % (correct, len(EXAMPLES))) def testInnerNamespaceSet(self): - proto = protocol.Parse(HELLO_WORLD.protocol_string) + proto = protocol.parse(HELLO_WORLD.protocol_string) self.assertEqual(proto.namespace, 'com.acme') greeting_type = proto.type_map['com.acme.Greeting'] self.assertEqual(greeting_type.namespace, 'com.acme') def testInnerNamespaceNotRendered(self): - proto = protocol.Parse(HELLO_WORLD.protocol_string) + proto = protocol.parse(HELLO_WORLD.protocol_string) self.assertEqual('com.acme.Greeting', proto.types[0].fullname) self.assertEqual('Greeting', proto.types[0].name) # but there shouldn't be 'namespace' rendered to json on the inner type @@ -451,9 +451,9 @@ def testValidCastToStringAfterParse(self): """ num_correct = 0 for example in VALID_EXAMPLES: - proto = protocol.Parse(example.protocol_string) + proto = protocol.parse(example.protocol_string) try: - protocol.Parse(str(proto)) + protocol.parse(str(proto)) logging.debug( 'Successfully reparsed protocol:\n%s', example.protocol_string) @@ -477,8 +477,8 @@ def testEquivalenceAfterRoundTrip(self): """ num_correct = 0 for example in VALID_EXAMPLES: - original_protocol = protocol.Parse(example.protocol_string) - round_trip_protocol = protocol.Parse(str(original_protocol)) + original_protocol = protocol.parse(example.protocol_string) + round_trip_protocol = protocol.parse(str(original_protocol)) if original_protocol == round_trip_protocol: num_correct += 1 diff --git a/lang/py3/avro/tests/test_schema.py b/lang/py3/avro/tests/test_schema.py index c8365288639..c201ed1e280 100644 --- a/lang/py3/avro/tests/test_schema.py +++ b/lang/py3/avro/tests/test_schema.py @@ -451,7 +451,7 @@ def MakePrimitiveExamples(): class TestSchema(unittest.TestCase): def testCorrectRecursiveExtraction(self): - parsed = schema.Parse(""" + parsed = schema.parse(""" { "type": "record", "name": "X", @@ -467,7 +467,7 @@ def testCorrectRecursiveExtraction(self): """) logging.debug('Parsed schema:\n%s', parsed) logging.debug('Fields: %s', parsed.fields) - t = schema.Parse(str(parsed.fields[0].type)) + t = schema.parse(str(parsed.fields[0].type)) # If we've made it this far, the subschema was reasonably stringified; # it could be reparsed. self.assertEqual("X", t.fields[0].type.name) @@ -477,7 +477,7 @@ def testParse(self): for iexample, example in enumerate(EXAMPLES): logging.debug('Testing example #%d\n%s', iexample, example.schema_string) try: - schema.Parse(example.schema_string) + schema.parse(example.schema_string) if example.valid: correct += 1 else: @@ -497,7 +497,7 @@ def testParse(self): self.assertEqual( correct, len(EXAMPLES), - 'Parse behavior correct on %d out of %d schemas.' + 'parse behavior correct on %d out of %d schemas.' % (correct, len(EXAMPLES)), ) @@ -508,8 +508,8 @@ def testValidCastToStringAfterParse(self): """ correct = 0 for example in VALID_EXAMPLES: - schema_data = schema.Parse(example.schema_string) - schema.Parse(str(schema_data)) + schema_data = schema.parse(example.schema_string) + schema.parse(str(schema_data)) correct += 1 fail_msg = "Cast to string success on %d out of %d schemas" % \ @@ -525,8 +525,8 @@ def testEquivalenceAfterRoundTrip(self): """ correct = 0 for example in VALID_EXAMPLES: - original_schema = schema.Parse(example.schema_string) - round_trip_schema = schema.Parse(str(original_schema)) + original_schema = schema.parse(example.schema_string) + round_trip_schema = schema.parse(str(original_schema)) if original_schema == round_trip_schema: correct += 1 debug_msg = "%s: ROUND TRIP SUCCESS" % example.name @@ -580,7 +580,7 @@ def testFullname(self): def testDocAttributes(self): correct = 0 for example in DOC_EXAMPLES: - original_schema = schema.Parse(example.schema_string) + original_schema = schema.parse(example.schema_string) if original_schema.doc is not None: correct += 1 if original_schema.type == 'record': @@ -595,8 +595,8 @@ def testOtherAttributes(self): correct = 0 props = {} for example in OTHER_PROP_EXAMPLES: - original_schema = schema.Parse(example.schema_string) - round_trip_schema = schema.Parse(str(original_schema)) + original_schema = schema.parse(example.schema_string) + round_trip_schema = schema.parse(str(original_schema)) self.assertEqual(original_schema.other_props,round_trip_schema.other_props) if original_schema.type == "record": field_props = 0 diff --git a/lang/py3/avro/tests/test_script.py b/lang/py3/avro/tests/test_script.py index 8fc72715c98..dcfe947ad4f 100644 --- a/lang/py3/avro/tests/test_script.py +++ b/lang/py3/avro/tests/test_script.py @@ -119,7 +119,7 @@ class TestCat(unittest.TestCase): @staticmethod def WriteAvroFile(file_path): - schema = avro.schema.Parse(SCHEMA) + schema = avro.schema.parse(SCHEMA) with open(file_path, 'wb') as writer: with avro.datafile.DataFileWriter( writer=writer, diff --git a/lang/py3/avro/txipc.py b/lang/py3/avro/txipc.py index 3a3e9178f31..9f0e2c4f457 100644 --- a/lang/py3/avro/txipc.py +++ b/lang/py3/avro/txipc.py @@ -82,14 +82,14 @@ def _set_total_bytes_sent(self, bytes_sent): total_bytes_sent = property(_get_total_bytes_sent, _set_total_bytes_sent) - def startProducing(self, consumer): + def start_producing(self, consumer): if self.started: return self.started = True self._consumer = consumer # Keep writing data to the consumer until we're finished, - # paused (pauseProducing()) or stopped (stopProducing()) + # paused (pause_producing()) or stopped (stop_producing()) while self.length - self.total_bytes_sent > 0 and \ not self.paused and not self.stopped: self.write() @@ -97,14 +97,14 @@ def startProducing(self, consumer): # the entire message to the consumer return self.deferred - def resumeProducing(self): + def resume_producing(self): self.paused = False self.write(self) - def pauseProducing(self): + def pause_producing(self): self.paused = True - def stopProducing(self): + def stop_producing(self): self.stopped = True def write(self): @@ -117,7 +117,7 @@ def write(self): self.total_bytes_sent += buffer_length # Make sure we wrote the entire message if self.total_bytes_sent == self.length and not self.stopped: - self.stopProducing() + self.stop_producing() # A message is always terminated by a zero-length buffer. self.write_buffer_length(0) self.deferred.callback(None) @@ -139,7 +139,7 @@ def __init__(self, finished): self.finished = finished self.message = [] - def dataReceived(self, data): + def data_received(self, data): self.recvd = self.recvd + data while len(self.recvd) >= ipc.BUFFER_HEADER_LENGTH: buffer_length ,= ipc.BIG_ENDIAN_INT_STRUCT.unpack( @@ -155,7 +155,7 @@ def dataReceived(self, data): self.recvd = self.recvd[buffer_length + ipc.BUFFER_HEADER_LENGTH:] self.message.append(buffer) - def connectionLost(self, reason): + def connection_lost(self, reason): if not self.done: self.finished.errback(ipc.ConnectionClosedException("Reader read 0 bytes.")) diff --git a/lang/py3/scripts/avro b/lang/py3/scripts/avro index 225cef2ccde..4457afa5099 100755 --- a/lang/py3/scripts/avro +++ b/lang/py3/scripts/avro @@ -213,7 +213,7 @@ def write(opts, files): try: with open(opts.schema, 'rt') as f: json_schema = f.read() - writer_schema = schema.Parse(json_schema) + writer_schema = schema.parse(json_schema) out = _open(opts.output, 'wb') except (IOError, OSError) as e: raise AvroError('Cannot open file - %s' % e)