use older yapf==0.28.0

tools/run_tests/xds_test_driver/framework/infrastructure/gcp/compute.py

@@ -50,8 +50,7 @@ class ComputeV1(gcp.api.GcpProjectApiResource):
         HTTP2 = enum.auto()
         GRPC = enum.auto()
 
-    def create_health_check_tcp(self,
-                                name,
+    def create_health_check_tcp(self, name,
                                 use_serving_port=False) -> GcpResource:
         health_check_settings = {}
         if use_serving_port:
@@ -113,12 +112,12 @@ class ComputeV1(gcp.api.GcpProjectApiResource):
         self._delete_resource(self.api.backendServices(), backendService=name)
 
     def create_url_map(
-        self,
-        name: str,
-        matcher_name: str,
-        src_hosts,
-        dst_default_backend_service: GcpResource,
-        dst_host_rule_match_backend_service: Optional[GcpResource] = None,
+            self,
+            name: str,
+            matcher_name: str,
+            src_hosts,
+            dst_default_backend_service: GcpResource,
+            dst_host_rule_match_backend_service: Optional[GcpResource] = None,
     ) -> GcpResource:
         if dst_host_rule_match_backend_service is None:
             dst_host_rule_match_backend_service = dst_default_backend_service
@@ -142,9 +141,9 @@ class ComputeV1(gcp.api.GcpProjectApiResource):
         self._delete_resource(self.api.urlMaps(), urlMap=name)
 
     def create_target_grpc_proxy(
-        self,
-        name: str,
-        url_map: GcpResource,
+            self,
+            name: str,
+            url_map: GcpResource,
     ) -> GcpResource:
         return self._insert_resource(self.api.targetGrpcProxies(), {
             'name': name,
@@ -157,9 +156,9 @@ class ComputeV1(gcp.api.GcpProjectApiResource):
                               targetGrpcProxy=name)
 
     def create_target_http_proxy(
-        self,
-        name: str,
-        url_map: GcpResource,
+            self,
+            name: str,
+            url_map: GcpResource,
     ) -> GcpResource:
         return self._insert_resource(self.api.targetHttpProxies(), {
             'name': name,
@@ -171,11 +170,11 @@ class ComputeV1(gcp.api.GcpProjectApiResource):
                               targetHttpProxy=name)
 
     def create_forwarding_rule(
-        self,
-        name: str,
-        src_port: int,
-        target_proxy: GcpResource,
-        network_url: str,
+            self,
+            name: str,
+            src_port: int,
+            target_proxy: GcpResource,
+            network_url: str,
     ) -> GcpResource:
         return self._insert_resource(
             self.api.globalForwardingRules(),
@@ -229,11 +228,11 @@ class ComputeV1(gcp.api.GcpProjectApiResource):
         return neg
 
     def wait_for_backends_healthy_status(
-        self,
-        backend_service,
-        backends,
-        timeout_sec=_WAIT_FOR_BACKEND_SEC,
-        wait_sec=4,
+            self,
+            backend_service,
+            backends,
+            timeout_sec=_WAIT_FOR_BACKEND_SEC,
+            wait_sec=4,
     ):
         pending = set(backends)
 

tools/run_tests/xds_test_driver/framework/infrastructure/k8s.py

@@ -95,8 +95,7 @@ class KubernetesNamespace:
     def get_service_account(self, name) -> V1Service:
         return self.api.core.read_namespaced_service_account(name, self.name)
 
-    def delete_service(self,
-                       name,
+    def delete_service(self, name,
                        grace_period_seconds=DELETE_GRACE_PERIOD_SEC):
         self.api.core.delete_namespaced_service(
             name=name,
@@ -273,11 +272,11 @@ class KubernetesNamespace:
         _wait_for_pod_started()
 
     def port_forward_pod(
-        self,
-        pod: V1Pod,
-        remote_port: int,
-        local_port: Optional[int] = None,
-        local_address: Optional[str] = None,
+            self,
+            pod: V1Pod,
+            remote_port: int,
+            local_port: Optional[int] = None,
+            local_address: Optional[str] = None,
     ) -> subprocess.Popen:
         """Experimental"""
         local_address = local_address or self.PORT_FORWARD_LOCAL_ADDRESS

tools/run_tests/xds_test_driver/framework/infrastructure/traffic_director.py

@@ -46,12 +46,12 @@ class TrafficDirectorManager:
     FORWARDING_RULE_NAME = "forwarding-rule"
 
     def __init__(
-        self,
-        gcp_api_manager: gcp.api.GcpApiManager,
-        project: str,
-        *,
-        resource_prefix: str,
-        network: str = 'default',
+            self,
+            gcp_api_manager: gcp.api.GcpApiManager,
+            project: str,
+            *,
+            resource_prefix: str,
+            network: str = 'default',
     ):
         # API
         self.compute = ComputeV1(gcp_api_manager, project)
@@ -181,9 +181,9 @@ class TrafficDirectorManager:
                                                       self.backends)
 
     def create_url_map(
-        self,
-        src_host: str,
-        src_port: int,
+            self,
+            src_host: str,
+            src_port: int,
     ) -> GcpResource:
         src_address = f'{src_host}:{src_port}'
         name = self._ns_name(self.URL_MAP_NAME)
@@ -279,12 +279,12 @@ class TrafficDirectorSecureManager(TrafficDirectorManager):
     GRPC_ENDPOINT_TARGET_URI = "unix:/var/cert/node-agent.0"
 
     def __init__(
-        self,
-        gcp_api_manager: gcp.api.GcpApiManager,
-        project: str,
-        *,
-        resource_prefix: str,
-        network: str = 'default',
+            self,
+            gcp_api_manager: gcp.api.GcpApiManager,
+            project: str,
+            *,
+            resource_prefix: str,
+            network: str = 'default',
     ):
         super().__init__(gcp_api_manager,
                          project,
@@ -450,9 +450,9 @@ class TrafficDirectorSecureManager(TrafficDirectorManager):
         self.client_tls_policy = None
 
     def backend_service_apply_client_mtls_policy(
-        self,
-        server_namespace,
-        server_name,
+            self,
+            server_namespace,
+            server_name,
     ):
         if not self.client_tls_policy:
             logger.warning(

tools/run_tests/xds_test_driver/framework/rpc/__init__.py

@@ -37,13 +37,13 @@ class GrpcClientHelper:
         self.service_name = re.sub('Stub$', '', self.stub.__class__.__name__)
 
     def call_unary_when_channel_ready(
-        self,
-        *,
-        rpc: str,
-        req: Message,
-        wait_for_ready_sec: Optional[int] = DEFAULT_WAIT_FOR_READY_SEC,
-        connection_timeout_sec: Optional[int] = DEFAULT_CONNECTION_TIMEOUT_SEC
-    ) -> Message:
+            self,
+            *,
+            rpc: str,
+            req: Message,
+            wait_for_ready_sec: Optional[int] = DEFAULT_WAIT_FOR_READY_SEC,
+            connection_timeout_sec: Optional[
+                int] = DEFAULT_CONNECTION_TIMEOUT_SEC) -> Message:
         if wait_for_ready_sec is None:
             wait_for_ready_sec = self.DEFAULT_WAIT_FOR_READY_SEC
         if connection_timeout_sec is None:

tools/run_tests/xds_test_driver/framework/rpc/grpc_testing.py

@@ -32,10 +32,10 @@ class LoadBalancerStatsServiceClient(framework.rpc.GrpcClientHelper):
         super().__init__(channel, test_pb2_grpc.LoadBalancerStatsServiceStub)
 
     def get_client_stats(
-        self,
-        *,
-        num_rpcs: int,
-        timeout_sec: Optional[int] = STATS_PARTIAL_RESULTS_TIMEOUT_SEC,
+            self,
+            *,
+            num_rpcs: int,
+            timeout_sec: Optional[int] = STATS_PARTIAL_RESULTS_TIMEOUT_SEC,
     ) -> LoadBalancerStatsResponse:
         if timeout_sec is None:
             timeout_sec = self.STATS_PARTIAL_RESULTS_TIMEOUT_SEC

tools/run_tests/xds_test_driver/framework/test_app/client_app.py

@@ -57,10 +57,10 @@ class XdsTestClient(framework.rpc.GrpcApp):
         return ChannelzServiceClient(self._make_channel(self.maintenance_port))
 
     def get_load_balancer_stats(
-        self,
-        *,
-        num_rpcs: int,
-        timeout_sec: Optional[int] = None,
+            self,
+            *,
+            num_rpcs: int,
+            timeout_sec: Optional[int] = None,
     ) -> grpc_testing.LoadBalancerStatsResponse:
         """
         Shortcut to LoadBalancerStatsServiceClient.get_client_stats()

tools/run_tests/xds_test_driver/framework/xds_k8s_testcase.py

@@ -367,7 +367,7 @@ class SecurityXdsKubernetesTestCase(XdsKubernetesTestCase):
 
     @staticmethod
     def getConnectedSockets(
-        test_client: XdsTestClient, test_server: XdsTestServer
+            test_client: XdsTestClient, test_server: XdsTestServer
     ) -> Tuple[grpc_channelz.Socket, grpc_channelz.Socket]:
         client_sock = test_client.get_client_socket_with_test_server()
         server_sock = test_server.get_server_socket_matching_client(client_sock)