use pep563

test/ir/inference/test_trt_convert_batch_norm.py

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import unittest
 from functools import partial
 from itertools import product
-from typing import Any, Dict, Generator, List, Tuple
+from typing import Any, Generator
 
 import numpy as np
 from program_config import ProgramConfig, TensorConfig
@@ -29,7 +31,7 @@ def is_program_valid(self, program_config: ProgramConfig) -> bool:
         return True
 
     def sample_program_configs(self):
-        def generate_input1(attrs: List[Dict[str, Any]], batch):
+        def generate_input1(attrs: list[dict[str, Any]], batch):
             if self.dims == 4:
                 if attrs[0]['data_layout'] == "NCHW":
                     return np.ones([batch, 3, 24, 24]).astype(np.float32)
@@ -40,19 +42,19 @@ def generate_input1(attrs: List[Dict[str, Any]], batch):
             elif self.dims == 2:
                 return np.ones([batch, 3]).astype(np.float32)
 
-        def generate_bias(attrs: List[Dict[str, Any]], batch):
+        def generate_bias(attrs: list[dict[str, Any]], batch):
             return np.full((3), 0.9).astype("float32")
 
-        def generate_mean(attrs: List[Dict[str, Any]], batch):
+        def generate_mean(attrs: list[dict[str, Any]], batch):
             return np.full((3), 0.9).astype("float32")
 
-        def generate_scale(attrs: List[Dict[str, Any]], batch):
+        def generate_scale(attrs: list[dict[str, Any]], batch):
             return np.full((3), 1.1).astype("float32")
 
-        def generate_variance(attrs: List[Dict[str, Any]], batch):
+        def generate_variance(attrs: list[dict[str, Any]], batch):
             return np.full((3), 1.2).astype("float32")
 
-        def generate_MomentumTensor(attrs: List[Dict[str, Any]], batch):
+        def generate_MomentumTensor(attrs: list[dict[str, Any]], batch):
             return np.full((3), 0.9).astype("float32")
 
         for dims, num_input, batch, epsilon, data_layout, momentum in product(
@@ -156,7 +158,7 @@ def generate_MomentumTensor(attrs: List[Dict[str, Any]], batch):
     def sample_predictor_configs(
         self, program_config
     ) -> Generator[
-        Any, Any, Tuple[paddle_infer.Config, List[int], float] | None
+        Any, Any, tuple[paddle_infer.Config, list[int], float] | None
     ]:
         def generate_dynamic_shape(attrs):
             if self.dims == 4:

test/ir/inference/test_trt_convert_depthwise_conv2d_transpose.py

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import unittest
 from functools import partial
 from itertools import product
-from typing import Any, Dict, Generator, List, Tuple
+from typing import Any, Generator
 
 import numpy as np
 from program_config import ProgramConfig, TensorConfig
@@ -56,12 +58,12 @@ def is_program_valid(self, program_config: ProgramConfig) -> bool:
     def sample_program_configs(self):
         self.trt_param.workspace_size = 1073741824
 
-        def generate_input1(batch, attrs: List[Dict[str, Any]]):
+        def generate_input1(batch, attrs: list[dict[str, Any]]):
             return np.ones([batch, attrs[0]['groups'], 64, 64]).astype(
                 np.float32
             )
 
-        def generate_weight1(attrs: List[Dict[str, Any]]):
+        def generate_weight1(attrs: list[dict[str, Any]]):
             return np.random.random([attrs[0]['groups'], 1, 3, 3]).astype(
                 np.float32
             )
@@ -130,7 +132,7 @@ def generate_weight1(attrs: List[Dict[str, Any]]):
     def sample_predictor_configs(
         self, program_config
     ) -> Generator[
-        Any, Any, Tuple[paddle_infer.Config, List[int], float] | None
+        Any, Any, tuple[paddle_infer.Config, list[int], float] | None
     ]:
         def generate_dynamic_shape(attrs):
             self.dynamic_shape.min_input_shape = {

test/ir/inference/test_trt_convert_nearest_interp.py

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import unittest
 from functools import partial
 from itertools import product
-from typing import Any, Dict, Generator, List, Tuple
+from typing import Any, Generator
 
 import numpy as np
 from program_config import ProgramConfig, TensorConfig
@@ -42,7 +44,7 @@ def is_program_valid(self, program_config: ProgramConfig) -> bool:
         return True
 
     def sample_program_configs(self):
-        def generate_input1(attrs: List[Dict[str, Any]]):
+        def generate_input1(attrs: list[dict[str, Any]]):
             return np.ones([1, 3, 64, 64]).astype(np.float32)
 
         for (
@@ -97,7 +99,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):
     def sample_predictor_configs(
         self, program_config
     ) -> Generator[
-        Any, Any, Tuple[paddle_infer.Config, List[int], float] | None
+        Any, Any, tuple[paddle_infer.Config, list[int], float] | None
     ]:
         def generate_dynamic_shape(attrs):
             self.dynamic_shape.min_input_shape = {"input_data": [1, 3, 32, 32]}

test/ir/inference/test_trt_convert_rnn.py

@@ -12,11 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import os
 import unittest
 from functools import partial
 from itertools import product
-from typing import Any, Generator, List, Tuple
+from typing import Any, Generator
 
 import numpy as np
 from program_config import ProgramConfig, TensorConfig
@@ -205,7 +207,7 @@ def generate_b():
     def sample_predictor_configs(
         self, program_config
     ) -> Generator[
-        Any, Any, Tuple[paddle_infer.Config, List[int], float] | None
+        Any, Any, tuple[paddle_infer.Config, list[int], float] | None
     ]:
         attrs = [
             program_config.ops[i].attrs for i in range(len(program_config.ops))

test/ir/inference/test_trt_convert_roi_align.py

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import unittest
 from functools import partial
 from itertools import product
-from typing import Any, Dict, Generator, List, Tuple
+from typing import Any, Generator
 
 import numpy as np
 from program_config import ProgramConfig, TensorConfig
@@ -29,13 +31,13 @@ def is_program_valid(self, program_config: ProgramConfig) -> bool:
         return True
 
     def sample_program_configs(self):
-        def generate_input1(attrs: List[Dict[str, Any]], batch):
+        def generate_input1(attrs: list[dict[str, Any]], batch):
             return np.ones([batch, 256, 32, 32]).astype(np.float32)
 
-        def generate_input2(attrs: List[Dict[str, Any]], batch):
+        def generate_input2(attrs: list[dict[str, Any]], batch):
             return np.random.random([3, 4]).astype(np.float32)
 
-        def generate_input3(attrs: List[Dict[str, Any]], batch):
+        def generate_input3(attrs: list[dict[str, Any]], batch):
             if batch == 1:
                 return np.array([3]).astype(np.int32)
             if batch == 2:
@@ -136,7 +138,7 @@ def generate_lod(batch):
     def sample_predictor_configs(
         self, program_config
     ) -> Generator[
-        Any, Any, Tuple[paddle_infer.Config, List[int], float] | None
+        Any, Any, tuple[paddle_infer.Config, list[int], float] | None
     ]:
         def generate_dynamic_shape(attrs):
             if self.num_input == 0:

test/ir/inference/test_trt_convert_scale.py

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import unittest
 from functools import partial
 from itertools import product
-from typing import Any, Dict, Generator, List, Tuple
+from typing import Any, Generator
 
 import numpy as np
 from program_config import ProgramConfig, TensorConfig
@@ -29,7 +31,7 @@ def is_program_valid(self, program_config: ProgramConfig) -> bool:
         return True
 
     def sample_program_configs(self):
-        def generate_input1(attrs: List[Dict[str, Any]], batch, is_int):
+        def generate_input1(attrs: list[dict[str, Any]], batch, is_int):
             if self.dims == 4:
                 return np.ones([batch, 3, 24, 24]).astype(
                     np.int32 if is_int else np.float32
@@ -47,7 +49,7 @@ def generate_input1(attrs: List[Dict[str, Any]], batch, is_int):
             elif self.dims == 0:
                 return np.ones([]).astype(np.int32 if is_int else np.float32)
 
-        def generate_weight1(attrs: List[Dict[str, Any]], is_int):
+        def generate_weight1(attrs: list[dict[str, Any]], is_int):
             return np.ones([1]).astype(np.int32 if is_int else np.float32)
 
         for (
@@ -130,7 +132,7 @@ def generate_weight1(attrs: List[Dict[str, Any]], is_int):
     def sample_predictor_configs(
         self, program_config
     ) -> Generator[
-        Any, Any, Tuple[paddle_infer.Config, List[int], float] | None
+        Any, Any, tuple[paddle_infer.Config, list[int], float] | None
     ]:
         def generate_dynamic_shape(attrs):
             if self.dims == 4:

test/ir/inference/test_trt_convert_strided_slice.py

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import unittest
 from functools import partial
 from itertools import product
-from typing import Any, Dict, Generator, List, Tuple
+from typing import Any, Generator
 
 import numpy as np
 from program_config import ProgramConfig, TensorConfig
@@ -34,7 +36,7 @@ def is_program_valid(self, program_config: ProgramConfig) -> bool:
         return True
 
     def sample_program_configs(self):
-        def generate_input1(attrs: List[Dict[str, Any]]):
+        def generate_input1(attrs: list[dict[str, Any]]):
             return np.random.random([1, 56, 56, 192]).astype(np.float32)
 
         for axes, starts, ends, decrease_axis, infer_flags, strides in product(
@@ -82,7 +84,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):
     def sample_predictor_configs(
         self, program_config
     ) -> Generator[
-        Any, Any, Tuple[paddle_infer.Config, List[int], float] | None
+        Any, Any, tuple[paddle_infer.Config, list[int], float] | None
     ]:
         def generate_dynamic_shape(attrs):
             self.dynamic_shape.min_input_shape = {
@@ -145,7 +147,7 @@ def is_program_valid(self, program_config: ProgramConfig) -> bool:
         return True
 
     def sample_program_configs(self):
-        def generate_input1(attrs: List[Dict[str, Any]]):
+        def generate_input1(attrs: list[dict[str, Any]]):
             return np.random.random([1, 56, 56, 192]).astype(np.float32)
 
         for axes in [[1, 2], [2, 3], [1, 3]]:
@@ -200,7 +202,9 @@ def generate_input1(attrs: List[Dict[str, Any]]):
 
     def sample_predictor_configs(
         self, program_config
-    ) -> (paddle_infer.Config, List[int], float):
+    ) -> Generator[
+        Any, Any, tuple[paddle_infer.Config, list[int], float] | None
+    ]:
         def generate_dynamic_shape():
             self.dynamic_shape.min_input_shape = {
                 "input_data": [1, 56, 56, 192]

test/ir/inference/test_trt_convert_trans_layernorm.py

@@ -11,10 +11,13 @@
 # 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.
+
+from __future__ import annotations
+
 import unittest
 from functools import partial
 from itertools import product
-from typing import Any, Generator, List, Tuple
+from typing import Any, Generator
 
 import numpy as np
 from program_config import ProgramConfig, TensorConfig
@@ -176,7 +179,7 @@ def conv2d_input_datagen(dics):
     def sample_predictor_configs(
         self, program_config
     ) -> Generator[
-        Any, Any, Tuple[paddle_infer.Config, List[int], float] | None
+        Any, Any, tuple[paddle_infer.Config, list[int], float] | None
     ]:
         def generate_dynamic_shape(attrs, inputs):
             conv2d_c = inputs['conv2d_input'].shape[1]

test/ir/inference/test_trt_convert_yolo_box.py

@@ -12,11 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import os
 import unittest
 from functools import partial
 from itertools import product
-from typing import Any, Dict, Generator, List, Tuple
+from typing import Any, Generator
 
 import numpy as np
 from program_config import ProgramConfig, TensorConfig
@@ -30,7 +32,7 @@ def is_program_valid(self, program_config: ProgramConfig) -> bool:
         return True
 
     def sample_program_configs(self):
-        def generate_input1(attrs: List[Dict[str, Any]], batch, channel):
+        def generate_input1(attrs: list[dict[str, Any]], batch, channel):
             if attrs[0]['iou_aware']:
                 return np.ones([batch, 3 * (channel + 6), 13, 13]).astype(
                     np.float32
@@ -40,7 +42,7 @@ def generate_input1(attrs: List[Dict[str, Any]], batch, channel):
                     np.float32
                 )
 
-        def generate_input2(attrs: List[Dict[str, Any]], batch):
+        def generate_input2(attrs: list[dict[str, Any]], batch):
             return np.random.random([batch, 2]).astype(np.int32)
 
         for (
@@ -120,7 +122,7 @@ def generate_input2(attrs: List[Dict[str, Any]], batch):
     def sample_predictor_configs(
         self, program_config
     ) -> Generator[
-        Any, Any, Tuple[paddle_infer.Config, List[int], float] | None
+        Any, Any, tuple[paddle_infer.Config, list[int], float] | None
     ]:
         def generate_dynamic_shape(attrs):
             if attrs[0]['iou_aware']: