Enable comprehension simplification in ruff rules (#23414)

Enable comprehension simplification rules (C4) for ruff and apply
autofix.

Author: justinchuby

docs/python/_common/onnx_sphinx.py

@@ -282,7 +282,7 @@ def get_domain_list():
     """
     Returns the list of available domains.
     """
-    return list(sorted(set(map(lambda s: s.domain, get_all_schemas_with_history()))))
+    return sorted({s.domain for s in get_all_schemas_with_history()})
 
 
 def get_operator_schemas(op_name, version=None, domain=None):
@@ -779,9 +779,9 @@ def render(self, indent=""):
                 name = op["name"]
                 dom = self.domain.replace(".", "-")
                 table_dom.append(f"    * - :ref:`l-onnx-doc{dom}-{name}`")
-                versions = list(reversed(sorted((k, v) for k, v in op["links"].items() if isinstance(k, int))))
+                versions = sorted(((k, v) for k, v in op["links"].items() if isinstance(k, int)), reverse=True)
                 col1 = ", ".join(f":ref:`{k} <{v}>`" for k, v in versions)
-                diffs = list(reversed(sorted((k, v) for k, v in op["links"].items() if isinstance(k, tuple))))
+                diffs = sorted(((k, v) for k, v in op["links"].items() if isinstance(k, tuple)), reverse=True)
                 col2 = ", ".join(f":ref:`{k[1]}/{k[0]} <{v}>`" for k, v in diffs)
                 table_dom.append(f"      - {col1}")
                 table_dom.append(f"      - {col2}")

onnxruntime/python/onnxruntime_inference_collection.py

@@ -138,10 +138,10 @@ def set_provider_options(name, options):
         if len(providers) != len(provider_options):
             raise ValueError("'providers' and 'provider_options' should be the same length if both are given.")
 
-        if not all([isinstance(provider, str) for provider in providers]):
+        if not all(isinstance(provider, str) for provider in providers):
             raise ValueError("Only string values for 'providers' are supported if 'provider_options' is given.")
 
-        if not all([isinstance(options_for_provider, dict) for options_for_provider in provider_options]):
+        if not all(isinstance(options_for_provider, dict) for options_for_provider in provider_options):
             raise ValueError("'provider_options' values must be dicts.")
 
         for name, options in zip(providers, provider_options, strict=False):
@@ -150,7 +150,7 @@ def set_provider_options(name, options):
     else:
         for provider in providers:
             if isinstance(provider, str):
-                set_provider_options(provider, dict())
+                set_provider_options(provider, {})
             elif (
                 isinstance(provider, tuple)
                 and len(provider) == 2

onnxruntime/python/tools/kernel_explorer/kernels/kernel_explorer.py

@@ -220,7 +220,7 @@ def set_dispatch(name):
         from difflib import SequenceMatcher as Matcher
 
         valid_names = list(_ke_context.dispatchable.keys())
-        scored_names = list(reversed(sorted([(Matcher(None, name, a).ratio(), a) for a in valid_names])))
+        scored_names = sorted([(Matcher(None, name, a).ratio(), a) for a in valid_names], reverse=True)
         top10 = "\n    ".join([a for _, a in scored_names[:10]])
         msg = f"'{name}' is not registered for dispatch. Top 10 matches are:\n    {top10}"
         print(msg)

onnxruntime/python/tools/profile_explorer/profile_explorer.py

@@ -200,7 +200,7 @@ def _print_op_kernel_mapping_info(cpu_df, gpu_df, num_runs, csv=None):
     # Count op occurrences in the selected runs
     op_counts = defaultdict(int)
     for op in cpu_df.T.to_dict().values():
-        identifiers = tuple([op["name"], op["input_type_shape"]])
+        identifiers = (op["name"], op["input_type_shape"])
         op_counts[identifiers] += 1
 
     # Collect kernel stats: count/duration
@@ -212,15 +212,15 @@ def _print_op_kernel_mapping_info(cpu_df, gpu_df, num_runs, csv=None):
         input_type_shape = kernel["input_type_shape"]
         kernel_name = kernel["name"]
         dimensions = kernel["dimensions"]
-        identifiers = tuple([op_name, input_type_shape, kernel_name, dimensions])
+        identifiers = (op_name, input_type_shape, kernel_name, dimensions)
         stat_dict[identifiers]["count"] += 1
         stat_dict[identifiers]["duration"] += kernel["duration"]
 
     # Create the DataFrame for kernel entries with op correlation info
     kernel_list = []
     for identifiers, stat in stat_dict.items():
         op_name, input_type_shape, kernel_name, dimensions = identifiers
-        op_count = op_counts.get(tuple([op_name, input_type_shape]))
+        op_count = op_counts.get((op_name, input_type_shape))
         if op_count is None:
             continue
         kernel_list.append(

onnxruntime/python/tools/quantization/base_quantizer.py

@@ -118,9 +118,9 @@ def __init__(
                     'Conv_4:0': [np.float32(1), np.float32(3.5)]
                 }
         """
-        if tensors_range is not None and any(map(lambda t: not isinstance(t, TensorData), tensors_range.values())):
+        if tensors_range is not None and any(not isinstance(t, TensorData) for t in tensors_range.values()):
             raise TypeError(
-                f"tensors_range contains unexpected types {set(type(v) for v in tensors_range.values())}, not TensorData."
+                f"tensors_range contains unexpected types { {type(v) for v in tensors_range.values()} }, not TensorData."
             )
         self.tensors_range = tensors_range
         self.nodes_to_quantize = nodes_to_quantize  # specific nodes to quantize

onnxruntime/python/tools/quantization/calibrate.py

@@ -504,9 +504,9 @@ def compute_data(self) -> TensorsData:
 
             if self.symmetric:
                 max_absolute_value = np.max([np.abs(min_value_array), np.abs(max_value_array)], axis=0)
-                pairs.append(tuple([-max_absolute_value, max_absolute_value]))
+                pairs.append((-max_absolute_value, max_absolute_value))
             else:
-                pairs.append(tuple([min_value_array, max_value_array]))
+                pairs.append((min_value_array, max_value_array))
 
         new_calibrate_tensors_range = TensorsData(
             CalibrationMethod.MinMax, dict(zip(calibrate_tensor_names, pairs, strict=False))
@@ -823,7 +823,7 @@ def collect_absolute_value(self, name_to_arr):
             if isinstance(data_arr, list):
                 for arr in data_arr:
                     assert isinstance(arr, np.ndarray), f"Unexpected type {type(arr)} for tensor={tensor!r}"
-                dtypes = set(a.dtype for a in data_arr)
+                dtypes = {a.dtype for a in data_arr}
                 assert len(dtypes) == 1, (
                     f"The calibration expects only one element type but got {dtypes} for tensor={tensor!r}"
                 )

onnxruntime/python/tools/quantization/execution_providers/qnn/mixed_precision_overrides_utils.py

@@ -178,7 +178,7 @@ def apply(
         # Use type requests to "fix" tensor quantization overrides by adding
         # quantization type conversions where necessary.
         for tensor_name, type_req in type_requests.items():
-            all_consumers = set([node.name for node in self.consumers.get(tensor_name, [])])
+            all_consumers = {node.name for node in self.consumers.get(tensor_name, [])}
             has_producer_req = type_req.producer is not None
             has_consumer_req = bool(type_req.consumers)
 

onnxruntime/python/tools/quantization/matmul_4bits_quantizer.py

@@ -1186,7 +1186,7 @@ def _generate_q4_node_config(self):
         }
         for node in self.model.model.graph.node:
             if node.op_type in ["MatMul"]:
-                if not all([self.model.get_initializer(i) is None for i in node.input]):
+                if not all(self.model.get_initializer(i) is None for i in node.input):
                     q4_node_config[node.name] = template_config_q4
         return q4_node_config
 

onnxruntime/python/tools/quantization/onnx_model.py

@@ -576,7 +576,7 @@ def _check_init(self, init, test=None):
         if init.data_type == onnx.TensorProto.FLOAT8E4M3FN:
             if init.HasField("raw_data"):
                 b = list(init.raw_data)
-                if any(map(lambda i: (i & 127) == 127, b)):
+                if any((i & 127) == 127 for i in b):
                     raise ValueError(f"Initializer {init.name!r} has nan.")
         return init
 

onnxruntime/python/tools/quantization/qdq_loss_debug.py

@@ -316,8 +316,8 @@ def create_weight_matching(float_model_path: str, qdq_model_path: str) -> dict[s
         # Perform dequantization:
         if weight_scale.size == weight_zp.size == 1:
             # Avoids the confusion between a scaler and a tensor of one element.
-            weight_scale = weight_scale.reshape(tuple())
-            weight_zp = weight_zp.reshape(tuple())
+            weight_scale = weight_scale.reshape(())
+            weight_zp = weight_zp.reshape(())
         if weight_scale.shape != weight_zp.shape:
             raise RuntimeError(
                 f"scale and zero_point must have the same shape but {weight_scale.shape} != {weight_zp.shape}"