yapf examples/python

examples/python/helloworld/greeter_client.py

@@ -11,7 +11,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
 """The Python implementation of the GRPC helloworld.Greeter client."""
 
 from __future__ import print_function
@@ -23,11 +22,11 @@ import helloworld_pb2_grpc
 
 
 def run():
-  channel = grpc.insecure_channel('localhost:50051')
-  stub = helloworld_pb2_grpc.GreeterStub(channel)
-  response = stub.SayHello(helloworld_pb2.HelloRequest(name='you'))
-  print("Greeter client received: " + response.message)
+    channel = grpc.insecure_channel('localhost:50051')
+    stub = helloworld_pb2_grpc.GreeterStub(channel)
+    response = stub.SayHello(helloworld_pb2.HelloRequest(name='you'))
+    print("Greeter client received: " + response.message)
 
 
 if __name__ == '__main__':
-  run()
+    run()

examples/python/helloworld/greeter_server.py

@@ -11,7 +11,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
 """The Python implementation of the GRPC helloworld.Greeter server."""
 
 from concurrent import futures
@@ -27,20 +26,21 @@ _ONE_DAY_IN_SECONDS = 60 * 60 * 24
 
 class Greeter(helloworld_pb2_grpc.GreeterServicer):
 
-  def SayHello(self, request, context):
-    return helloworld_pb2.HelloReply(message='Hello, %s!' % request.name)
+    def SayHello(self, request, context):
+        return helloworld_pb2.HelloReply(message='Hello, %s!' % request.name)
 
 
 def serve():
-  server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
-  helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
-  server.add_insecure_port('[::]:50051')
-  server.start()
-  try:
-    while True:
-      time.sleep(_ONE_DAY_IN_SECONDS)
-  except KeyboardInterrupt:
-    server.stop(0)
+    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
+    helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
+    server.add_insecure_port('[::]:50051')
+    server.start()
+    try:
+        while True:
+            time.sleep(_ONE_DAY_IN_SECONDS)
+    except KeyboardInterrupt:
+        server.stop(0)
+
 
 if __name__ == '__main__':
-  serve()
+    serve()

examples/python/multiplex/multiplex_client.py

@@ -11,7 +11,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
 """A client that makes both Greeter and RouteGuide RPCs."""
 
 from __future__ import print_function
@@ -29,98 +28,99 @@ import route_guide_resources
 
 
 def make_route_note(message, latitude, longitude):
-  return route_guide_pb2.RouteNote(
-      message=message,
-      location=route_guide_pb2.Point(latitude=latitude, longitude=longitude))
+    return route_guide_pb2.RouteNote(
+        message=message,
+        location=route_guide_pb2.Point(latitude=latitude, longitude=longitude))
 
 
 def guide_get_one_feature(route_guide_stub, point):
-  feature = route_guide_stub.GetFeature(point)
-  if not feature.location:
-    print("Server returned incomplete feature")
-    return
+    feature = route_guide_stub.GetFeature(point)
+    if not feature.location:
+        print("Server returned incomplete feature")
+        return
 
-  if feature.name:
-    print("Feature called %s at %s" % (feature.name, feature.location))
-  else:
-    print("Found no feature at %s" % feature.location)
+    if feature.name:
+        print("Feature called %s at %s" % (feature.name, feature.location))
+    else:
+        print("Found no feature at %s" % feature.location)
 
 
 def guide_get_feature(route_guide_stub):
-  guide_get_one_feature(
-      route_guide_stub,
-      route_guide_pb2.Point(latitude=409146138, longitude=-746188906))
-  guide_get_one_feature(
-      route_guide_stub, route_guide_pb2.Point(latitude=0, longitude=0))
+    guide_get_one_feature(
+        route_guide_stub,
+        route_guide_pb2.Point(latitude=409146138, longitude=-746188906))
+    guide_get_one_feature(route_guide_stub,
+                          route_guide_pb2.Point(latitude=0, longitude=0))
 
 
 def guide_list_features(route_guide_stub):
-  rectangle = route_guide_pb2.Rectangle(
-      lo=route_guide_pb2.Point(latitude=400000000, longitude=-750000000),
-      hi=route_guide_pb2.Point(latitude=420000000, longitude=-730000000))
-  print("Looking for features between 40, -75 and 42, -73")
+    rectangle = route_guide_pb2.Rectangle(
+        lo=route_guide_pb2.Point(latitude=400000000, longitude=-750000000),
+        hi=route_guide_pb2.Point(latitude=420000000, longitude=-730000000))
+    print("Looking for features between 40, -75 and 42, -73")
 
-  features = route_guide_stub.ListFeatures(rectangle)
+    features = route_guide_stub.ListFeatures(rectangle)
 
-  for feature in features:
-    print("Feature called %s at %s" % (feature.name, feature.location))
+    for feature in features:
+        print("Feature called %s at %s" % (feature.name, feature.location))
 
 
 def generate_route(feature_list):
-  for _ in range(0, 10):
-    random_feature = feature_list[random.randint(0, len(feature_list) - 1)]
-    print("Visiting point %s" % random_feature.location)
-    yield random_feature.location
-    time.sleep(random.uniform(0.5, 1.5))
+    for _ in range(0, 10):
+        random_feature = feature_list[random.randint(0, len(feature_list) - 1)]
+        print("Visiting point %s" % random_feature.location)
+        yield random_feature.location
+        time.sleep(random.uniform(0.5, 1.5))
 
 
 def guide_record_route(route_guide_stub):
-  feature_list = route_guide_resources.read_route_guide_database()
+    feature_list = route_guide_resources.read_route_guide_database()
 
-  route_iterator = generate_route(feature_list)
-  route_summary = route_guide_stub.RecordRoute(route_iterator)
-  print("Finished trip with %s points " % route_summary.point_count)
-  print("Passed %s features " % route_summary.feature_count)
-  print("Travelled %s meters " % route_summary.distance)
-  print("It took %s seconds " % route_summary.elapsed_time)
+    route_iterator = generate_route(feature_list)
+    route_summary = route_guide_stub.RecordRoute(route_iterator)
+    print("Finished trip with %s points " % route_summary.point_count)
+    print("Passed %s features " % route_summary.feature_count)
+    print("Travelled %s meters " % route_summary.distance)
+    print("It took %s seconds " % route_summary.elapsed_time)
 
 
 def generate_messages():
-  messages = [
-      make_route_note("First message", 0, 0),
-      make_route_note("Second message", 0, 1),
-      make_route_note("Third message", 1, 0),
-      make_route_note("Fourth message", 0, 0),
-      make_route_note("Fifth message", 1, 0),
-  ]
-  for msg in messages:
-    print("Sending %s at %s" % (msg.message, msg.location))
-    yield msg
-    time.sleep(random.uniform(0.5, 1.0))
+    messages = [
+        make_route_note("First message", 0, 0),
+        make_route_note("Second message", 0, 1),
+        make_route_note("Third message", 1, 0),
+        make_route_note("Fourth message", 0, 0),
+        make_route_note("Fifth message", 1, 0),
+    ]
+    for msg in messages:
+        print("Sending %s at %s" % (msg.message, msg.location))
+        yield msg
+        time.sleep(random.uniform(0.5, 1.0))
 
 
 def guide_route_chat(route_guide_stub):
-  responses = route_guide_stub.RouteChat(generate_messages())
-  for response in responses:
-    print("Received message %s at %s" % (response.message, response.location))
+    responses = route_guide_stub.RouteChat(generate_messages())
+    for response in responses:
+        print("Received message %s at %s" %
+              (response.message, response.location))
 
 
 def run():
-  channel = grpc.insecure_channel('localhost:50051')
-  greeter_stub = helloworld_pb2_grpc.GreeterStub(channel)
-  route_guide_stub = route_guide_pb2_grpc.RouteGuideStub(channel)
-  greeter_response = greeter_stub.SayHello(
-      helloworld_pb2.HelloRequest(name='you'))
-  print("Greeter client received: " + greeter_response.message)
-  print("-------------- GetFeature --------------")
-  guide_get_feature(route_guide_stub)
-  print("-------------- ListFeatures --------------")
-  guide_list_features(route_guide_stub)
-  print("-------------- RecordRoute --------------")
-  guide_record_route(route_guide_stub)
-  print("-------------- RouteChat --------------")
-  guide_route_chat(route_guide_stub)
+    channel = grpc.insecure_channel('localhost:50051')
+    greeter_stub = helloworld_pb2_grpc.GreeterStub(channel)
+    route_guide_stub = route_guide_pb2_grpc.RouteGuideStub(channel)
+    greeter_response = greeter_stub.SayHello(
+        helloworld_pb2.HelloRequest(name='you'))
+    print("Greeter client received: " + greeter_response.message)
+    print("-------------- GetFeature --------------")
+    guide_get_feature(route_guide_stub)
+    print("-------------- ListFeatures --------------")
+    guide_list_features(route_guide_stub)
+    print("-------------- RecordRoute --------------")
+    guide_record_route(route_guide_stub)
+    print("-------------- RouteChat --------------")
+    guide_route_chat(route_guide_stub)
 
 
 if __name__ == '__main__':
-  run()
+    run()

examples/python/multiplex/multiplex_server.py

@@ -11,7 +11,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
 """A gRPC server servicing both Greeter and RouteGuide RPCs."""
 
 from concurrent import futures
@@ -30,107 +29,111 @@ _ONE_DAY_IN_SECONDS = 60 * 60 * 24
 
 
 def _get_feature(feature_db, point):
-  """Returns Feature at given location or None."""
-  for feature in feature_db:
-    if feature.location == point:
-      return feature
-  return None
+    """Returns Feature at given location or None."""
+    for feature in feature_db:
+        if feature.location == point:
+            return feature
+    return None
 
 
 def _get_distance(start, end):
-  """Distance between two points."""
-  coord_factor = 10000000.0
-  lat_1 = start.latitude / coord_factor
-  lat_2 = end.latitude / coord_factor
-  lon_1 = start.longitude / coord_factor
-  lon_2 = end.longitude / coord_factor
-  lat_rad_1 = math.radians(lat_1)
-  lat_rad_2 = math.radians(lat_2)
-  delta_lat_rad = math.radians(lat_2 - lat_1)
-  delta_lon_rad = math.radians(lon_2 - lon_1)
-
-  a = (pow(math.sin(delta_lat_rad / 2), 2) +
-       (math.cos(lat_rad_1) * math.cos(lat_rad_2) *
-        pow(math.sin(delta_lon_rad / 2), 2)))
-  c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
-  R = 6371000; # metres
-  return R * c;
+    """Distance between two points."""
+    coord_factor = 10000000.0
+    lat_1 = start.latitude / coord_factor
+    lat_2 = end.latitude / coord_factor
+    lon_1 = start.longitude / coord_factor
+    lon_2 = end.longitude / coord_factor
+    lat_rad_1 = math.radians(lat_1)
+    lat_rad_2 = math.radians(lat_2)
+    delta_lat_rad = math.radians(lat_2 - lat_1)
+    delta_lon_rad = math.radians(lon_2 - lon_1)
+
+    a = (pow(math.sin(delta_lat_rad / 2), 2) +
+         (math.cos(lat_rad_1) * math.cos(lat_rad_2) * pow(
+             math.sin(delta_lon_rad / 2), 2)))
+    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
+    R = 6371000
+    # metres
+    return R * c
 
 
 class _GreeterServicer(helloworld_pb2_grpc.GreeterServicer):
 
-  def SayHello(self, request, context):
-    return helloworld_pb2.HelloReply(message='Hello, {}!'.format(request.name))
+    def SayHello(self, request, context):
+        return helloworld_pb2.HelloReply(
+            message='Hello, {}!'.format(request.name))
 
 
 class _RouteGuideServicer(route_guide_pb2_grpc.RouteGuideServicer):
-  """Provides methods that implement functionality of route guide server."""
-
-  def __init__(self):
-    self.db = route_guide_resources.read_route_guide_database()
-
-  def GetFeature(self, request, context):
-    feature = _get_feature(self.db, request)
-    if feature is None:
-      return route_guide_pb2.Feature(name="", location=request)
-    else:
-      return feature
-
-  def ListFeatures(self, request, context):
-    left = min(request.lo.longitude, request.hi.longitude)
-    right = max(request.lo.longitude, request.hi.longitude)
-    top = max(request.lo.latitude, request.hi.latitude)
-    bottom = min(request.lo.latitude, request.hi.latitude)
-    for feature in self.db:
-      if (feature.location.longitude >= left and
-          feature.location.longitude <= right and
-          feature.location.latitude >= bottom and
-          feature.location.latitude <= top):
-        yield feature
-
-  def RecordRoute(self, request_iterator, context):
-    point_count = 0
-    feature_count = 0
-    distance = 0.0
-    prev_point = None
-
-    start_time = time.time()
-    for point in request_iterator:
-      point_count += 1
-      if _get_feature(self.db, point):
-        feature_count += 1
-      if prev_point:
-        distance += _get_distance(prev_point, point)
-      prev_point = point
-
-    elapsed_time = time.time() - start_time
-    return route_guide_pb2.RouteSummary(point_count=point_count,
-                                        feature_count=feature_count,
-                                        distance=int(distance),
-                                        elapsed_time=int(elapsed_time))
-
-  def RouteChat(self, request_iterator, context):
-    prev_notes = []
-    for new_note in request_iterator:
-      for prev_note in prev_notes:
-        if prev_note.location == new_note.location:
-          yield prev_note
-      prev_notes.append(new_note)
+    """Provides methods that implement functionality of route guide server."""
+
+    def __init__(self):
+        self.db = route_guide_resources.read_route_guide_database()
+
+    def GetFeature(self, request, context):
+        feature = _get_feature(self.db, request)
+        if feature is None:
+            return route_guide_pb2.Feature(name="", location=request)
+        else:
+            return feature
+
+    def ListFeatures(self, request, context):
+        left = min(request.lo.longitude, request.hi.longitude)
+        right = max(request.lo.longitude, request.hi.longitude)
+        top = max(request.lo.latitude, request.hi.latitude)
+        bottom = min(request.lo.latitude, request.hi.latitude)
+        for feature in self.db:
+            if (feature.location.longitude >= left and
+                    feature.location.longitude <= right and
+                    feature.location.latitude >= bottom and
+                    feature.location.latitude <= top):
+                yield feature
+
+    def RecordRoute(self, request_iterator, context):
+        point_count = 0
+        feature_count = 0
+        distance = 0.0
+        prev_point = None
+
+        start_time = time.time()
+        for point in request_iterator:
+            point_count += 1
+            if _get_feature(self.db, point):
+                feature_count += 1
+            if prev_point:
+                distance += _get_distance(prev_point, point)
+            prev_point = point
+
+        elapsed_time = time.time() - start_time
+        return route_guide_pb2.RouteSummary(
+            point_count=point_count,
+            feature_count=feature_count,
+            distance=int(distance),
+            elapsed_time=int(elapsed_time))
+
+    def RouteChat(self, request_iterator, context):
+        prev_notes = []
+        for new_note in request_iterator:
+            for prev_note in prev_notes:
+                if prev_note.location == new_note.location:
+                    yield prev_note
+            prev_notes.append(new_note)
 
 
 def serve():
-  server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
-  helloworld_pb2_grpc.add_GreeterServicer_to_server(_GreeterServicer(), server)
-  route_guide_pb2_grpc.add_RouteGuideServicer_to_server(
-      _RouteGuideServicer(), server)
-  server.add_insecure_port('[::]:50051')
-  server.start()
-  try:
-    while True:
-      time.sleep(_ONE_DAY_IN_SECONDS)
-  except KeyboardInterrupt:
-    server.stop(0)
+    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
+    helloworld_pb2_grpc.add_GreeterServicer_to_server(_GreeterServicer(),
+                                                      server)
+    route_guide_pb2_grpc.add_RouteGuideServicer_to_server(_RouteGuideServicer(),
+                                                          server)
+    server.add_insecure_port('[::]:50051')
+    server.start()
+    try:
+        while True:
+            time.sleep(_ONE_DAY_IN_SECONDS)
+    except KeyboardInterrupt:
+        server.stop(0)
 
 
 if __name__ == '__main__':
-  serve()
+    serve()

examples/python/multiplex/route_guide_resources.py

@@ -11,7 +11,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
 """Common resources used in the gRPC route guide example."""
 
 import json
@@ -20,19 +19,19 @@ import route_guide_pb2
 
 
 def read_route_guide_database():
-  """Reads the route guide database.
+    """Reads the route guide database.
 
   Returns:
     The full contents of the route guide database as a sequence of
       route_guide_pb2.Features.
   """
-  feature_list = []
-  with open("route_guide_db.json") as route_guide_db_file:
-    for item in json.load(route_guide_db_file):
-      feature = route_guide_pb2.Feature(
-          name=item["name"],
-          location=route_guide_pb2.Point(
-              latitude=item["location"]["latitude"],
-              longitude=item["location"]["longitude"]))
-      feature_list.append(feature)
-  return feature_list
+    feature_list = []
+    with open("route_guide_db.json") as route_guide_db_file:
+        for item in json.load(route_guide_db_file):
+            feature = route_guide_pb2.Feature(
+                name=item["name"],
+                location=route_guide_pb2.Point(
+                    latitude=item["location"]["latitude"],
+                    longitude=item["location"]["longitude"]))
+            feature_list.append(feature)
+    return feature_list

examples/python/multiplex/run_codegen.py

@@ -11,26 +11,11 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
 """Generates protocol messages and gRPC stubs."""
 
 from grpc_tools import protoc
 
-protoc.main(
-    (
-        '',
-        '-I../../protos',
-        '--python_out=.',
-        '--grpc_python_out=.',
-        '../../protos/helloworld.proto',
-    )
-)
-protoc.main(
-    (
-        '',
-        '-I../../protos',
-        '--python_out=.',
-        '--grpc_python_out=.',
-        '../../protos/route_guide.proto',
-    )
-)
+protoc.main(('', '-I../../protos', '--python_out=.', '--grpc_python_out=.',
+             '../../protos/helloworld.proto',))
+protoc.main(('', '-I../../protos', '--python_out=.', '--grpc_python_out=.',
+             '../../protos/route_guide.proto',))

examples/python/route_guide/route_guide_client.py

@@ -11,7 +11,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
 """The Python implementation of the gRPC route guide client."""
 
 from __future__ import print_function
@@ -26,89 +25,91 @@ import route_guide_resources
 
 
 def make_route_note(message, latitude, longitude):
-  return route_guide_pb2.RouteNote(
-      message=message,
-      location=route_guide_pb2.Point(latitude=latitude, longitude=longitude))
+    return route_guide_pb2.RouteNote(
+        message=message,
+        location=route_guide_pb2.Point(latitude=latitude, longitude=longitude))
 
 
 def guide_get_one_feature(stub, point):
-  feature = stub.GetFeature(point)
-  if not feature.location:
-    print("Server returned incomplete feature")
-    return
+    feature = stub.GetFeature(point)
+    if not feature.location:
+        print("Server returned incomplete feature")
+        return
 
-  if feature.name:
-    print("Feature called %s at %s" % (feature.name, feature.location))
-  else:
-    print("Found no feature at %s" % feature.location)
+    if feature.name:
+        print("Feature called %s at %s" % (feature.name, feature.location))
+    else:
+        print("Found no feature at %s" % feature.location)
 
 
 def guide_get_feature(stub):
-  guide_get_one_feature(stub, route_guide_pb2.Point(latitude=409146138, longitude=-746188906))
-  guide_get_one_feature(stub, route_guide_pb2.Point(latitude=0, longitude=0))
+    guide_get_one_feature(
+        stub, route_guide_pb2.Point(latitude=409146138, longitude=-746188906))
+    guide_get_one_feature(stub, route_guide_pb2.Point(latitude=0, longitude=0))
 
 
 def guide_list_features(stub):
-  rectangle = route_guide_pb2.Rectangle(
-      lo=route_guide_pb2.Point(latitude=400000000, longitude=-750000000),
-      hi=route_guide_pb2.Point(latitude=420000000, longitude=-730000000))
-  print("Looking for features between 40, -75 and 42, -73")
+    rectangle = route_guide_pb2.Rectangle(
+        lo=route_guide_pb2.Point(latitude=400000000, longitude=-750000000),
+        hi=route_guide_pb2.Point(latitude=420000000, longitude=-730000000))
+    print("Looking for features between 40, -75 and 42, -73")
 
-  features = stub.ListFeatures(rectangle)
+    features = stub.ListFeatures(rectangle)
 
-  for feature in features:
-    print("Feature called %s at %s" % (feature.name, feature.location))
+    for feature in features:
+        print("Feature called %s at %s" % (feature.name, feature.location))
 
 
 def generate_route(feature_list):
-  for _ in range(0, 10):
-    random_feature = feature_list[random.randint(0, len(feature_list) - 1)]
-    print("Visiting point %s" % random_feature.location)
-    yield random_feature.location
+    for _ in range(0, 10):
+        random_feature = feature_list[random.randint(0, len(feature_list) - 1)]
+        print("Visiting point %s" % random_feature.location)
+        yield random_feature.location
 
 
 def guide_record_route(stub):
-  feature_list = route_guide_resources.read_route_guide_database()
+    feature_list = route_guide_resources.read_route_guide_database()
 
-  route_iterator = generate_route(feature_list)
-  route_summary = stub.RecordRoute(route_iterator)
-  print("Finished trip with %s points " % route_summary.point_count)
-  print("Passed %s features " % route_summary.feature_count)
-  print("Travelled %s meters " % route_summary.distance)
-  print("It took %s seconds " % route_summary.elapsed_time)
+    route_iterator = generate_route(feature_list)
+    route_summary = stub.RecordRoute(route_iterator)
+    print("Finished trip with %s points " % route_summary.point_count)
+    print("Passed %s features " % route_summary.feature_count)
+    print("Travelled %s meters " % route_summary.distance)
+    print("It took %s seconds " % route_summary.elapsed_time)
 
 
 def generate_messages():
-  messages = [
-      make_route_note("First message", 0, 0),
-      make_route_note("Second message", 0, 1),
-      make_route_note("Third message", 1, 0),
-      make_route_note("Fourth message", 0, 0),
-      make_route_note("Fifth message", 1, 0),
-  ]
-  for msg in messages:
-    print("Sending %s at %s" % (msg.message, msg.location))
-    yield msg
+    messages = [
+        make_route_note("First message", 0, 0),
+        make_route_note("Second message", 0, 1),
+        make_route_note("Third message", 1, 0),
+        make_route_note("Fourth message", 0, 0),
+        make_route_note("Fifth message", 1, 0),
+    ]
+    for msg in messages:
+        print("Sending %s at %s" % (msg.message, msg.location))
+        yield msg
 
 
 def guide_route_chat(stub):
-  responses = stub.RouteChat(generate_messages())
-  for response in responses:
-    print("Received message %s at %s" % (response.message, response.location))
+    responses = stub.RouteChat(generate_messages())
+    for response in responses:
+        print("Received message %s at %s" %
+              (response.message, response.location))
 
 
 def run():
-  channel = grpc.insecure_channel('localhost:50051')
-  stub = route_guide_pb2_grpc.RouteGuideStub(channel)
-  print("-------------- GetFeature --------------")
-  guide_get_feature(stub)
-  print("-------------- ListFeatures --------------")
-  guide_list_features(stub)
-  print("-------------- RecordRoute --------------")
-  guide_record_route(stub)
-  print("-------------- RouteChat --------------")
-  guide_route_chat(stub)
+    channel = grpc.insecure_channel('localhost:50051')
+    stub = route_guide_pb2_grpc.RouteGuideStub(channel)
+    print("-------------- GetFeature --------------")
+    guide_get_feature(stub)
+    print("-------------- ListFeatures --------------")
+    guide_list_features(stub)
+    print("-------------- RecordRoute --------------")
+    guide_record_route(stub)
+    print("-------------- RouteChat --------------")
+    guide_route_chat(stub)
 
 
 if __name__ == '__main__':
-  run()
+    run()

examples/python/route_guide/route_guide_resources.py

@@ -11,7 +11,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
 """Common resources used in the gRPC route guide example."""
 
 import json
@@ -20,19 +19,19 @@ import route_guide_pb2
 
 
 def read_route_guide_database():
-  """Reads the route guide database.
+    """Reads the route guide database.
 
   Returns:
     The full contents of the route guide database as a sequence of
       route_guide_pb2.Features.
   """
-  feature_list = []
-  with open("route_guide_db.json") as route_guide_db_file:
-    for item in json.load(route_guide_db_file):
-      feature = route_guide_pb2.Feature(
-          name=item["name"],
-          location=route_guide_pb2.Point(
-              latitude=item["location"]["latitude"],
-              longitude=item["location"]["longitude"]))
-      feature_list.append(feature)
-  return feature_list
+    feature_list = []
+    with open("route_guide_db.json") as route_guide_db_file:
+        for item in json.load(route_guide_db_file):
+            feature = route_guide_pb2.Feature(
+                name=item["name"],
+                location=route_guide_pb2.Point(
+                    latitude=item["location"]["latitude"],
+                    longitude=item["location"]["longitude"]))
+            feature_list.append(feature)
+    return feature_list

examples/python/route_guide/route_guide_server.py

@@ -11,7 +11,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
 """The Python implementation of the gRPC route guide server."""
 
 from concurrent import futures
@@ -28,98 +27,102 @@ _ONE_DAY_IN_SECONDS = 60 * 60 * 24
 
 
 def get_feature(feature_db, point):
-  """Returns Feature at given location or None."""
-  for feature in feature_db:
-    if feature.location == point:
-      return feature
-  return None
+    """Returns Feature at given location or None."""
+    for feature in feature_db:
+        if feature.location == point:
+            return feature
+    return None
 
 
 def get_distance(start, end):
-  """Distance between two points."""
-  coord_factor = 10000000.0
-  lat_1 = start.latitude / coord_factor
-  lat_2 = end.latitude / coord_factor
-  lon_1 = start.longitude / coord_factor
-  lon_2 = end.longitude / coord_factor
-  lat_rad_1 = math.radians(lat_1)
-  lat_rad_2 = math.radians(lat_2)
-  delta_lat_rad = math.radians(lat_2 - lat_1)
-  delta_lon_rad = math.radians(lon_2 - lon_1)
-
-  a = (pow(math.sin(delta_lat_rad / 2), 2) +
-       (math.cos(lat_rad_1) * math.cos(lat_rad_2) *
-        pow(math.sin(delta_lon_rad / 2), 2)))
-  c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
-  R = 6371000; # metres
-  return R * c;
+    """Distance between two points."""
+    coord_factor = 10000000.0
+    lat_1 = start.latitude / coord_factor
+    lat_2 = end.latitude / coord_factor
+    lon_1 = start.longitude / coord_factor
+    lon_2 = end.longitude / coord_factor
+    lat_rad_1 = math.radians(lat_1)
+    lat_rad_2 = math.radians(lat_2)
+    delta_lat_rad = math.radians(lat_2 - lat_1)
+    delta_lon_rad = math.radians(lon_2 - lon_1)
+
+    a = (pow(math.sin(delta_lat_rad / 2), 2) +
+         (math.cos(lat_rad_1) * math.cos(lat_rad_2) * pow(
+             math.sin(delta_lon_rad / 2), 2)))
+    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
+    R = 6371000
+    # metres
+    return R * c
+
 
 class RouteGuideServicer(route_guide_pb2_grpc.RouteGuideServicer):
-  """Provides methods that implement functionality of route guide server."""
-
-  def __init__(self):
-    self.db = route_guide_resources.read_route_guide_database()
-
-  def GetFeature(self, request, context):
-    feature = get_feature(self.db, request)
-    if feature is None:
-      return route_guide_pb2.Feature(name="", location=request)
-    else:
-      return feature
-
-  def ListFeatures(self, request, context):
-    left = min(request.lo.longitude, request.hi.longitude)
-    right = max(request.lo.longitude, request.hi.longitude)
-    top = max(request.lo.latitude, request.hi.latitude)
-    bottom = min(request.lo.latitude, request.hi.latitude)
-    for feature in self.db:
-      if (feature.location.longitude >= left and
-          feature.location.longitude <= right and
-          feature.location.latitude >= bottom and
-          feature.location.latitude <= top):
-        yield feature
-
-  def RecordRoute(self, request_iterator, context):
-    point_count = 0
-    feature_count = 0
-    distance = 0.0
-    prev_point = None
-
-    start_time = time.time()
-    for point in request_iterator:
-      point_count += 1
-      if get_feature(self.db, point):
-        feature_count += 1
-      if prev_point:
-        distance += get_distance(prev_point, point)
-      prev_point = point
-
-    elapsed_time = time.time() - start_time
-    return route_guide_pb2.RouteSummary(point_count=point_count,
-                                        feature_count=feature_count,
-                                        distance=int(distance),
-                                        elapsed_time=int(elapsed_time))
-
-  def RouteChat(self, request_iterator, context):
-    prev_notes = []
-    for new_note in request_iterator:
-      for prev_note in prev_notes:
-        if prev_note.location == new_note.location:
-          yield prev_note
-      prev_notes.append(new_note)
+    """Provides methods that implement functionality of route guide server."""
+
+    def __init__(self):
+        self.db = route_guide_resources.read_route_guide_database()
+
+    def GetFeature(self, request, context):
+        feature = get_feature(self.db, request)
+        if feature is None:
+            return route_guide_pb2.Feature(name="", location=request)
+        else:
+            return feature
+
+    def ListFeatures(self, request, context):
+        left = min(request.lo.longitude, request.hi.longitude)
+        right = max(request.lo.longitude, request.hi.longitude)
+        top = max(request.lo.latitude, request.hi.latitude)
+        bottom = min(request.lo.latitude, request.hi.latitude)
+        for feature in self.db:
+            if (feature.location.longitude >= left and
+                    feature.location.longitude <= right and
+                    feature.location.latitude >= bottom and
+                    feature.location.latitude <= top):
+                yield feature
+
+    def RecordRoute(self, request_iterator, context):
+        point_count = 0
+        feature_count = 0
+        distance = 0.0
+        prev_point = None
+
+        start_time = time.time()
+        for point in request_iterator:
+            point_count += 1
+            if get_feature(self.db, point):
+                feature_count += 1
+            if prev_point:
+                distance += get_distance(prev_point, point)
+            prev_point = point
+
+        elapsed_time = time.time() - start_time
+        return route_guide_pb2.RouteSummary(
+            point_count=point_count,
+            feature_count=feature_count,
+            distance=int(distance),
+            elapsed_time=int(elapsed_time))
+
+    def RouteChat(self, request_iterator, context):
+        prev_notes = []
+        for new_note in request_iterator:
+            for prev_note in prev_notes:
+                if prev_note.location == new_note.location:
+                    yield prev_note
+            prev_notes.append(new_note)
 
 
 def serve():
-  server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
-  route_guide_pb2_grpc.add_RouteGuideServicer_to_server(
-      RouteGuideServicer(), server)
-  server.add_insecure_port('[::]:50051')
-  server.start()
-  try:
-    while True:
-      time.sleep(_ONE_DAY_IN_SECONDS)
-  except KeyboardInterrupt:
-    server.stop(0)
+    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
+    route_guide_pb2_grpc.add_RouteGuideServicer_to_server(RouteGuideServicer(),
+                                                          server)
+    server.add_insecure_port('[::]:50051')
+    server.start()
+    try:
+        while True:
+            time.sleep(_ONE_DAY_IN_SECONDS)
+    except KeyboardInterrupt:
+        server.stop(0)
+
 
 if __name__ == '__main__':
-  serve()
+    serve()

examples/python/route_guide/run_codegen.py

@@ -11,17 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
 """Runs protoc with the gRPC plugin to generate messages and gRPC stubs."""
 
 from grpc_tools import protoc
 
-protoc.main(
-    (
-	'',
-	'-I../../protos',
-	'--python_out=.',
-	'--grpc_python_out=.',
-	'../../protos/route_guide.proto',
-    )
-)
+protoc.main(('', '-I../../protos', '--python_out=.', '--grpc_python_out=.',
+             '../../protos/route_guide.proto',))

tools/distrib/yapf_code.sh

@@ -19,9 +19,11 @@ set -ex
 cd "$(dirname "${0}")/../.."
 
 DIRS=(
+    'examples/python'
     'src/python'
 )
 EXCLUSIONS=(
+    '*_pb2*.py'
 )
 
 VIRTUALENV=yapf_virtual_environment