Remove E741 from ruff lint ignore rules (#2601)

Author: tpremrud

pyproject.toml

@@ -161,7 +161,6 @@ ignore = [
     "E712",  # https://docs.astral.sh/ruff/rules/true-false-comparison/
     "E721",  # https://docs.astral.sh/ruff/rules/type-comparison/
     "E722",  # https://docs.astral.sh/ruff/rules/bare-except/
-    "E741",  # https://docs.astral.sh/ruff/rules/ambiguous-variable-name/
 ]
 
 [tool.ruff.lint.per-file-ignores]

thunder/clang/__init__.py

@@ -453,10 +453,10 @@ def _basic_indexing(a: TensorLike, /, key) -> TensorLike:
 
     # Handles numbers and slices
     squeeze_dims = []
-    for idx, (l, x) in enumerate(zip(a.shape, key)):
+    for idx, (length, x) in enumerate(zip(a.shape, key)):
         if isinstance(x, slice):
             start = x.start if x.start is not None else 0
-            stop = x.stop if x.stop is not None else l
+            stop = x.stop if x.stop is not None else length
             step = x.step if x.step is not None else 1
 
             # Tests for negative step (PyTorch doesn't allow step < 1)
@@ -465,11 +465,11 @@ def _basic_indexing(a: TensorLike, /, key) -> TensorLike:
             # Canonicalizes start and stop (allowing for values like -1)
             # NOTE: canonicalization is custom because start and stop beyond the length are allowed
             if start < 0:
-                start = start + l
-            utils.check(start >= 0, lambda: f"start={x.start} is not a valid index for length {l}")
+                start = start + length
+            utils.check(start >= 0, lambda: f"start={x.start} is not a valid index for length {length}")
             if stop < 0:
-                stop = stop + l
-            utils.check(stop >= 0, lambda: f"end={x.stop} is not a valid index for length {l}")
+                stop = stop + length
+            utils.check(stop >= 0, lambda: f"end={x.stop} is not a valid index for length {length}")
 
             # Handles start > stop, which occurs with slices like 3:1:1
             # NOTE Because step is always strictly positive, it's sufficient to check start
@@ -480,19 +480,19 @@ def _basic_indexing(a: TensorLike, /, key) -> TensorLike:
 
             # Handles overflow
             # NOTE This is a little odd, but we just want the slice to be zero
-            if start >= l:
+            if start >= length:
                 start = 0
                 stop = 0
 
-            if stop >= l:
-                stop = l
+            if stop >= length:
+                stop = length
 
             start_indices.append(start)
             end_indices.append(stop)
             strides.append(step)
         elif isinstance(x, (Number, NumberProxy)):
             # NOTE Numbers must be valid indices after canonicalization, unlike start and stop
-            x = utils.canonicalize_dim(l, x)
+            x = utils.canonicalize_dim(length, x)
             start_indices.append(x)
             end_indices.append(x + 1)
             strides.append(1)
@@ -504,7 +504,7 @@ def _basic_indexing(a: TensorLike, /, key) -> TensorLike:
     # performance optimization; check if we need slicing
     if (
         all([x == 0 for x in start_indices])
-        and all([x == l for x, l in zip(end_indices, a.shape)])
+        and all([x == length for x, length in zip(end_indices, a.shape)])
         and all([x == 1 for x in strides])
         and len(squeeze_dims) == 0
     ):
@@ -804,11 +804,11 @@ def reshape(a: TensorLike, shape: Sequence[int]) -> TensorLike:
     # Checks for -1 marker value
     numel = 1
     neg_one_idx = None
-    for idx, l in enumerate(shape):
-        if l >= 0:
-            numel *= l
+    for idx, length in enumerate(shape):
+        if length >= 0:
+            numel *= length
         else:
-            utils.check(l == -1, "Found a negative dimension length {l} in shape={shape}!")
+            utils.check(length == -1, "Found a negative dimension length {length} in shape={shape}!")
             utils.check(neg_one_idx is None, "Found two -1 markers in shape={shape}!")
             neg_one_idx = idx
 

thunder/core/baseutils.py

@@ -193,8 +193,8 @@ def check_valid_shape(shape: tuple[int, NumberProxy, ...] | list[int]):
 
     check_type(shape, (tuple, list))
 
-    for l in shape:
-        check_valid_length(l)
+    for length in shape:
+        check_valid_length(length)
 
 
 #

thunder/core/interpreter.py

@@ -193,21 +193,21 @@ def unwrap(self):
 # Note: Use these with care!
 #       In some situations - in particular *args/**kwargs, Python creates tuples and dicts for us,
 #       these functions are intended to do the appropriate wrapping for them.
-def wrap_args_from_list(l):  # returns a new list!
-    res = [_interpret_call(lambda l, i: l[i], l, wrap_const(i)) for i in range(len(unwrap(l)))]
+def wrap_args_from_list(lst):  # returns a new list!
+    res = [_interpret_call(lambda seq, i: seq[i], lst, wrap_const(i)) for i in range(len(unwrap(lst)))]
     return res
 
 
 def wrap_kwargs_from_dict(d):  # returns a new dict
     return {k: _interpret_call(lambda d, k: d[k], d, wrap_const(k)) for k in unwrap(d)}
 
 
-def wrapped_build_tuple(l: Sequence[WrappedValue]) -> WrappedValue:
-    assert all(isinstance(v, WrappedValue) for v in l)
-    if l:
-        pr = ProvenanceRecord(PseudoInst.BUILD_TUPLE, inputs=[v.provenance for v in l][::-1])  # other inst?
-        out = wrap(tuple(v.value for v in l), provenance=pr)
-        out.item_wrappers = list(l)
+def wrapped_build_tuple(seq: Sequence[WrappedValue]) -> WrappedValue:
+    assert all(isinstance(v, WrappedValue) for v in seq)
+    if seq:
+        pr = ProvenanceRecord(PseudoInst.BUILD_TUPLE, inputs=[v.provenance for v in seq][::-1])  # other inst?
+        out = wrap(tuple(v.value for v in seq), provenance=pr)
+        out.item_wrappers = list(seq)
     else:
         # Note: if we revisit returning const here instead of an empty tuple from BUILD_TUPLE, we need to add this to wrap_aergs
         out = wrap_const(())
@@ -336,36 +336,36 @@ def wrap_binary_subscr(uvalue, obj, key):
     return wrap(uvalue, provenance=ProvenanceRecord(PseudoInst.BINARY_SUBSCR, inputs=[obj.provenance, key.provenance]))
 
 
-def populate_item_wrappers(l):
+def populate_item_wrappers(obj):
     ctx: InterpreterCompileCtx = get_interpretercompilectx()
     if not ctx._with_provenance_tracking:
         return
 
-    assert isinstance(l, WrappedValue)
+    assert isinstance(obj, WrappedValue)
     # to do: generalize
-    if wrapped_isinstance(l, (list, tuple)):
-        if l.item_wrappers is None:
-            l.item_wrappers = [None for _ in range(len(l.value))]
-        assert isinstance(l.item_wrappers, list)
-        assert len(l.value) == len(l.item_wrappers), f"{len(l.value)=} {len(l.item_wrappers)=}"
-
-        for i, v in enumerate(l.value):
-            if l.item_wrappers[i] is None:
-                wv = wrap_binary_subscr(v, l, i)
-                l.item_wrappers[i] = wv
+    if wrapped_isinstance(obj, (list, tuple)):
+        if obj.item_wrappers is None:
+            obj.item_wrappers = [None for _ in range(len(obj.value))]
+        assert isinstance(obj.item_wrappers, list)
+        assert len(obj.value) == len(obj.item_wrappers), f"{len(obj.value)=} {len(obj.item_wrappers)=}"
+
+        for i, v in enumerate(obj.value):
+            if obj.item_wrappers[i] is None:
+                wv = wrap_binary_subscr(v, obj, i)
+                obj.item_wrappers[i] = wv
         return
 
-    if wrapped_isinstance(l, dict):
-        assert isinstance(l.item_wrappers, dict)
-        for k, v in l.value.items():
-            if k not in l.item_wrappers:
+    if wrapped_isinstance(obj, dict):
+        assert isinstance(obj.item_wrappers, dict)
+        for k, v in obj.value.items():
+            if k not in obj.item_wrappers:
                 wk = wrap_const(k)
-                wv = wrap_binary_subscr(v, l, wk)
-                l.item_wrappers[k] = wv
-                l.key_wrappers[k] = wk  # or have those from an iteration of the input?
+                wv = wrap_binary_subscr(v, obj, wk)
+                obj.item_wrappers[k] = wv
+                obj.key_wrappers[k] = wk  # or have those from an iteration of the input?
         return
 
-    raise NotImplementedError(f"populate item wrappers for {type(l.value)}")
+    raise NotImplementedError(f"populate item wrappers for {type(obj.value)}")
 
 
 #
@@ -883,15 +883,15 @@ def __init__(self, frame: FrameType):
 
     def format_with_source(self):
         assert self.positions is not None, self
-        l = []
-        l.append(f"  in {self.qualname} in file: {self.code.co_filename}, line {self.positions.lineno}:")
+        lst = []
+        lst.append(f"  in {self.qualname} in file: {self.code.co_filename}, line {self.positions.lineno}:")
         if self.code.co_filename:
             ls = linecache.getlines(self.code.co_filename)
             lineno = self.positions.lineno
             if lineno is None:
                 lineno = self.code.co_firstlineno
-            l.append("  " + ls[max(lineno - 1, 0)].rstrip())
-        return os.linesep.join(l)
+            lst.append("  " + ls[max(lineno - 1, 0)].rstrip())
+        return os.linesep.join(lst)
 
     def get_or_make_python_frame(self) -> FrameType:
         return self.frame
@@ -980,10 +980,10 @@ def recurse_str(self):
             inputs = [recurse_str(i) for i in self.inputs]
             inputs_str = ", ".join(inputs)
             counter += 1
-            l = f"  i{counter} = {self.inst}({inputs_str})"
+            out_item = f"  i{counter} = {self.inst}({inputs_str})"
             if self.output_idx != 0 or self.output_key is not None:
-                l += "# with output spec"
-            out.append(l)
+                out_item += "# with output spec"
+            out.append(out_item)
             res = f"i{counter}"
             known[self] = res
             return res
@@ -1034,11 +1034,11 @@ def unpack_provenance_record(self, wrapped_value, key: int | slice | None = None
             return wrapped_value
         # key=None is pop
         if isinstance(key, slice):
-            l = len(self._stack)
+            length = len(self._stack)
             if key.start is not None:
                 start = key.start
             else:
-                start = -l
+                start = -length
             assert start < 0
             if key.step is not None:
                 step = key.step
@@ -1156,18 +1156,18 @@ def nexti(self, inst: dis.Instruction):
     def format_with_source(self) -> str:
         # todo: multiple lines in positions, underline, indent
         assert self.positions is not None, self
-        l = []
-        l.append(f"  in {self.qualname} in file: {self.code.co_filename}, line {self.positions.lineno}:")
+        lines = []
+        lines.append(f"  in {self.qualname} in file: {self.code.co_filename}, line {self.positions.lineno}:")
         if self.code.co_filename:
             ls = linecache.getlines(self.code.co_filename)
             if ls:
                 lineno = self.positions.lineno
                 if lineno is None:
                     lineno = self.code.co_firstlineno
-                l.append("  " + ls[max(lineno - 1, 0)].rstrip())
+                lines.append("  " + ls[max(lineno - 1, 0)].rstrip())
             else:
-                l.append("  <unavailable>")
-        return os.linesep.join(l)
+                lines.append("  <unavailable>")
+        return os.linesep.join(lines)
 
     def get_localsplus_name(self, idx: int) -> str:
         if sys.version_info < (3, 11):
@@ -1194,7 +1194,7 @@ def get_or_make_python_frame(self) -> FrameType:
         name = self.code.co_name
         qualname = self.qualname
 
-        def get_frame(l, rel_lineno, filename, firstlineno, name, qualname):
+        def get_frame(container, rel_lineno, filename, firstlineno, name, qualname):
             def fn():
                 pass
 
@@ -1219,7 +1219,7 @@ def fn():
             assert tb is not None
             while tb.tb_next is not None:
                 tb = tb.tb_next
-            l.append(tb.tb_frame)
+            container.append(tb.tb_frame)
 
         # we run the getting of the frame in a separate thread because
         # we want to avoid having f_back pointing to the function
@@ -2133,15 +2133,15 @@ class SequenceWrapperMethods(WrappedValue):
     def __init__(self, iterable=(), /):
         if iterable == ():
             iterable = wrap_const(())
-        l = wrap_const([])
-        assert l.item_wrappers is not None
+        wrapped_list = wrap_const([])
+        assert wrapped_list.item_wrappers is not None
 
-        res = _interpret_call(list.extend, l, iterable)
+        res = _interpret_call(list.extend, wrapped_list, iterable)
         if res is INTERPRETER_SIGNALS.EXCEPTION_RAISED:
             return res
         assert type(self.value) is self.python_typ
-        self.value[:] = l.value[:]
-        self.item_wrappers = l.item_wrappers[:]
+        self.value[:] = wrapped_list.value[:]
+        self.item_wrappers = wrapped_list.item_wrappers[:]
         return wrap_const(None)
 
     def __getitem__(self, idx, /):
@@ -2195,10 +2195,10 @@ def __mul__(self, n, /):
         self.track_items()
 
         def impl(self, n):
-            l = []
+            seq = []
             for _ in range(n):
-                l.extend(self)
-            return type(self)(l)
+                seq.extend(self)
+            return type(self)(seq)
 
         return _interpret_call(impl, self, n)
 
@@ -2336,9 +2336,9 @@ def extend(self, iterable, /):
 
         if not isinstance(iterable.value, (tuple, list)):
 
-            def impl(l, iterable):
+            def impl(seq, iterable):
                 for i in iterable:
-                    l.append(i)
+                    seq.append(i)
 
             res = _interpret_call(impl, self, iterable)
             assert len(self.value) == len(self.item_wrappers)
@@ -2392,7 +2392,7 @@ def pop(self, index=-1, /):
         if uindex < -len(uself) or uindex >= len(uself):
             return do_raise(IndexError("pop index out of range"))
 
-        res = _interpret_call(lambda l, i: l[i], self, index)
+        res = _interpret_call(lambda seq, i: seq[i], self, index)
 
         assert res is not INTERPRETER_SIGNALS.EXCEPTION_RAISED
 
@@ -2873,7 +2873,7 @@ def _tuple_new_provenance_tracking_lookaside(cls, iterable=(), /):
         item_wrappers = []
         # TODO: investigate why just taking the wrappers will break test_interpreter.py::test_module_hooks
         for i in range(len(iterable.value)):
-            item_wrappers.append(_interpret_call(lambda l, i: l[i], iterable, wrap_const(i)))
+            item_wrappers.append(_interpret_call(lambda seq, i: seq[i], iterable, wrap_const(i)))
     else:
         iterator = _interpret_call(iter, iterable)
         if iterator is INTERPRETER_SIGNALS.EXCEPTION_RAISED:
@@ -4818,14 +4818,14 @@ def _list_append_handler(inst: dis.Instruction, /, stack: InterpreterStack, **kw
 
     # NOTE Doesn't pop the list that's extended
     tos = stack.pop_wrapped()
-    l: list = stack.getitem_wrapped(-i)
+    lst: list = stack.getitem_wrapped(-i)
 
-    assert wrapped_isinstance(l, list)
+    assert wrapped_isinstance(lst, list)
 
-    def impl(l, tos):
-        l.append(tos)
+    def impl(lst, tos):
+        lst.append(tos)
 
-    res = _interpret_call(impl, l, tos)
+    res = _interpret_call(impl, lst, tos)
     if res is INTERPRETER_SIGNALS.EXCEPTION_RAISED:
         return res
 
@@ -4838,11 +4838,11 @@ def _list_extend_handler(inst: dis.Instruction, /, stack: InterpreterStack, **kw
 
     # NOTE Doesn't pop the list that's extended
     tos = stack.pop_wrapped()
-    l: list = stack.getitem_wrapped(-i)
+    lst: list = stack.getitem_wrapped(-i)
 
     # NOTE tos does not have to be a list
-    assert wrapped_isinstance(l, list)
-    res = _interpret_call(lambda l1, l2: l1.extend(l2), l, tos)
+    assert wrapped_isinstance(lst, list)
+    res = _interpret_call(lambda l1, l2: l1.extend(l2), lst, tos)
 
     if res is INTERPRETER_SIGNALS.EXCEPTION_RAISED:
         return res

thunder/core/jit_ext.py

@@ -1842,11 +1842,11 @@ def from_provenance(provenance, *, new_output=False):
         return p
 
     with tracectx(prologue_trace):
-        for n, l in (("args", len(args)), ("kwargs", len(kwargs))):
+        for n, length in (("args", len(args)), ("kwargs", len(kwargs))):
             output = Proxy(name=n)
             bsym = prims.unpack_trivial.bind(output, output=output, name=n)
             prologue_trace.bound_symbols.append(bsym)
-            bsym = prims.check_len.bind(output, l, output=None)
+            bsym = prims.check_len.bind(output, length, output=None)
             prologue_trace.bound_symbols.append(bsym)
             if n == "args":
                 pro_args_proxy = output