ruff G010

• Rewriting `obj.warn` to `obj.warning` changes behavior if `obj` defines a custom `.warn` method distinct from `.warning` (e.g., in a test mock or wrapper class).
• If `warn` is accessed via `getattr(obj, 'warn')` dynamically, the textual replacement does not affect the attribute lookup and may leave stale code.
• When `warn` appears inside a string literal or comment, the tool should not modify it, but overzealous matching could corrupt documentation or logging configuration strings.
• If `warn` is part of a larger identifier like `warning_prefix`, the replacement would produce `warning_prefixing`, causing a NameError or unintended variable reference.
• In code using `logging.Logger.warn` via a bound method stored earlier (e.g., `log_method = logger.warn; log_method()`), rewriting the source does not update the stored reference, leading to continued use of the deprecated method.
• If the logger object is conditionally assigned (e.g., `logger = debug_logger if DEBUG else null_logger`) and only one branch defines `.warn`, the rewrite may incorrectly apply to a fallback object lacking `.warning`.
• When `lint.logger-objects` includes a logger imported via `from x import y as z`, the tool may fail to recognize the alias and either miss the violation or incorrectly rewrite non-logger uses of `z`.
• If the code defines a local variable named `warn` in the same scope (e.g., `warn = 42; logger.warn()`), the rewrite could ambiguously interfere with that variable though unlikely due to attribute access syntax.
• In Flask apps, if `current_app` is accessed outside an application context, the rewrite does not fix the underlying runtime error but may create false confidence in correctness.
• When multiple logger-like objects exist (e.g., `access_logger` and `error_logger`), the tool might incorrectly apply the fix based on naming heuristics even if only one is a true logger per `lint.logger-objects`.

--- orig.py	2026-10-17 16:24:27.826896136 -0400
+++ fixed.py	2026-10-17 16:24:28.077895473 -0400
@@ -4,8 +4,8 @@
 access_logger = logging.getLogger('access')  # Not in lint.logger-objects
 # Rule should fire on error_logger.warn but NOT on access_logger.warn
 try:
-    error_logger.warn('error msg')   # Should become .warning
-    access_logger.warn('access msg') # Should NOT be changed (heuristic overreach)
+    error_logger.warning('error msg')   # Should become .warning
+    access_logger.warning('access msg') # Should NOT be changed (heuristic overreach)
 except Exception as e:
     print(f'Error: {type(e).__name__}: {e}')
 print('Done')

Done

--- orig.py	2026-10-17 16:24:28.224895086 -0400
+++ fixed.py	2026-10-17 16:24:28.482894406 -0400
@@ -1,16 +1,16 @@
 import logging
 logger = logging.getLogger('test')
 try:
-    logger.warn('about to fail')  # Rewritten to .warning
+    logger.warning('about to fail')  # Rewritten to .warning
     raise ValueError('bad')
 except ValueError as e:
     try:
-        logger.warn('in except')  # Rewritten
+        logger.warning('in except')  # Rewritten
         raise RuntimeError('chained') from e
     except RuntimeError as final_err:
         pass
 else:
-    logger.warn('no ex')  # Rewritten
+    logger.warning('no ex')  # Rewritten
 finally:
-    logger.warn('cleanup')  # Rewritten
+    logger.warning('cleanup')  # Rewritten
 print('Finished')

Finished

Called via getattr

--- orig.py	2026-10-17 16:24:28.838893468 -0400
+++ fixed.py	2026-10-17 16:24:29.085892819 -0400
@@ -4,5 +4,5 @@
 # Rule rewrites: logger.warn(...) -> logger.warning(...) but NOT log_method
 log_method('stored call')  # Still uses .warn
 # New calls use .warning
-logger.warn('direct call')  # Now .warning
+logger.warning('direct call')  # Now .warning
 print('Stored vs direct')

Stored vs direct

--- orig.py	2026-10-17 16:24:29.227892446 -0400
+++ fixed.py	2026-10-17 16:24:29.478891788 -0400
@@ -2,5 +2,5 @@
 logger = logging.getLogger('test')
 warn = 99  # Local variable, not interfering with attribute access
 # Rule rewrites: logger.warn(...) -> logger.warning(...)
-logger.warn('value:', warn)  # arg 'warn' is the var 99
+logger.warning('value:', warn)  # arg 'warn' is the var 99
 print(f'Local warn={warn}')

Local warn=99

--- orig.py	2026-10-17 16:24:29.621891413 -0400
+++ fixed.py	2026-10-17 16:24:29.858890792 -0400
@@ -7,6 +7,6 @@
 d[WeirdDict()] = 'first'
 d[WeirdDict()] = 'second'  # Different key due to __eq__
 # Rule rewrites both:
-logger.warn('dict len:', len(d))  # Becomes .warning
-logger.warn('weird:', d)        # Becomes .warning
+logger.warning('dict len:', len(d))  # Becomes .warning
+logger.warning('weird:', d)        # Becomes .warning
 print(f'dict size: {len(d)}')

dict size: 2

--- orig.py	2026-10-17 16:24:30.005890406 -0400
+++ fixed.py	2026-10-17 16:24:30.271889712 -0400
@@ -4,5 +4,5 @@
 # Rule should ONLY replace .warn(...) -> .warning(...), NOT touch identifiers
 # So: logger.warn(warning_prefix + 'fix') -> logger.warning(warning_prefix + 'fix')
 # SAFE: no substring replacement in identifiers
-logger.warn(warning_prefix + 'fix')  # Correctly becomes .warning
+logger.warning(warning_prefix + 'fix')  # Correctly becomes .warning
 print(f'Prefix: {warning_prefix}')

Prefix: pre-

--- orig.py	2026-10-17 16:24:30.450889245 -0400
+++ fixed.py	2026-10-17 16:24:30.718888546 -0400
@@ -3,9 +3,9 @@
 with open('test_out.txt', 'w') as f:
     f.write('start\n')
     # Rule rewrites: logger.warn(...) -> logger.warning(...)
-    logger.warn('log to file', f)  # Passing file obj as arg
+    logger.warning('log to file', f)  # Passing file obj as arg
     f.write('middle\n')
-    logger.warn('more log')
+    logger.warning('more log')
     f.write('end\n')
 with open('test_out.txt', 'r') as f:
     print(f.read(), end='')

start
middle
end

WARN: test
WARNING: test

This is a warn message in a string
No change expected

--- orig.py	2026-10-17 16:24:36.413873903 -0400
+++ fixed.py	2026-10-17 16:24:36.668873256 -0400
@@ -2,6 +2,6 @@
 logger = logging.getLogger()
 logger.setLevel(logging.INFO)
 name = 'Alice'
-logger.warn('Hello %s' % name)
-logger.warn(f'Hello {name}')
-logger.warn('Hello {}'.format(name))
+logger.warning('Hello %s' % name)
+logger.warning(f'Hello {name}')
+logger.warning('Hello {}'.format(name))

--- orig.py	2026-10-17 16:24:36.818872876 -0400
+++ fixed.py	2026-10-17 16:24:37.063872256 -0400
@@ -1,6 +1,6 @@
 import logging
 logger = logging.getLogger()
 logger.setLevel(logging.INFO)
-gen = (logger.warn(f'Processing {x}') for x in range(2))
+gen = (logger.warning(f'Processing {x}') for x in range(2))
 print('First consumption:', list(gen))
 print('Second consumption:', list(gen))

First consumption: [None, None]
Second consumption: []

--- orig.py	2026-10-17 16:24:37.206871895 -0400
+++ fixed.py	2026-10-17 16:24:37.375871469 -0400
@@ -6,6 +6,6 @@
     pass  # No warn or warning
 logger = DebugLogger() if DEBUG else NullLogger()
 try:
-    logger.warn('test')
+    logger.warning('test')
 except AttributeError as e:
     print(type(e).__name__, str(e))

AttributeError 'NullLogger' object has no attribute 'warn'

--- orig.py	2026-10-17 16:24:37.698870654 -0400
+++ fixed.py	2026-10-17 16:24:37.943870036 -0400
@@ -1,5 +1,5 @@
 import logging
 my_logger = logging.getLogger()
 my_logger.setLevel(logging.INFO)
-my_logger.warn('test')
+my_logger.warning('test')
 print('Done')

Done

--- orig.py	2026-10-17 16:24:38.071869714 -0400
+++ fixed.py	2026-10-17 16:24:38.323869081 -0400
@@ -4,6 +4,6 @@
 logger.setLevel(logging.INFO)
 handler = io.StringIO()
 logger.addHandler(logging.StreamHandler(handler))
-logger.warn(b'byte string')
-logger.warn('str string')
+logger.warning(b'byte string')
+logger.warning('str string')
 print(handler.getvalue())

b'byte string'
str string