Merge branch 'main' into inspect-signature-fast-params

Author: eendebakpt

Lib/idlelib/config.py

@@ -25,7 +25,7 @@
 """
 # TODOs added Oct 2014, tjr
 
-from configparser import ConfigParser
+from configparser import ConfigParser, Error as ConfigParserError
 import os
 import sys
 
@@ -74,7 +74,7 @@ def GetOptionList(self, section):
     def Load(self):
         "Load the configuration file from disk."
         if self.file and os.path.exists(self.file):
-            with open(self.file, encoding='utf-8', errors='replace') as f:
+            with open(self.file, encoding='utf-8') as f:
                 self.read_file(f)
 
 class IdleUserConfParser(IdleConfParser):
@@ -159,6 +159,7 @@ def __init__(self, _utest=False):
         self.defaultCfg = {}
         self.userCfg = {}
         self.cfg = {}  # TODO use to select userCfg vs defaultCfg
+        self.file_load_errors = []  # (file, error) for unparsable cfg files.
 
         # See https://bugs.python.org/issue4630#msg356516 for following.
         # self.blink_off_time = <first editor text>['insertofftime']
@@ -795,7 +796,28 @@ def LoadCfgFiles(self):
         "Load all configuration files."
         for key in self.defaultCfg:
             self.defaultCfg[key].Load()
-            self.userCfg[key].Load() #same keys
+            try:
+                self.userCfg[key].Load()  # same keys
+            except (ConfigParserError, UnicodeDecodeError) as err:
+                # Move an invalid user file aside instead of losing it
+                # or failing to start (gh-66172).
+                file = self.userCfg[key].file
+                self.file_load_errors.append((file, err))
+                try:
+                    os.replace(file, file + '.bad')
+                except OSError:
+                    pass
+
+    def file_load_error_message(self):
+        "Return a warning about invalid config files, or None."
+        if not self.file_load_errors:
+            return None
+        files = '\n'.join(
+            f'  {file}:\n    {type(err).__name__}: {str(err).splitlines()[0]}'
+            for file, err in self.file_load_errors)
+        return ('The following IDLE configuration files could not be read.  '
+                'They were renamed by appending ".bad", and default settings '
+                'are used instead:\n\n' + files)
 
     def SaveUserCfgFiles(self):
         "Write all loaded user configuration files to disk."

Lib/idlelib/idle_test/test_config.py

@@ -312,6 +312,49 @@ def test_load_cfg_files(self):
         eq(conf.userCfg['foo'].Get('Foo Bar', 'foo'), 'newbar')
         eq(conf.userCfg['foo'].GetOptionList('Foo Bar'), ['foo'])
 
+    def test_load_cfg_files_bad_format(self):
+        # gh-66172: rename an unparsable user file and save the exception.
+        conf = self.new_config(_utest=True)
+        tmpdir = tempfile.TemporaryDirectory()
+        self.addCleanup(tmpdir.cleanup)
+        confpath = os.path.join(tmpdir.name, 'config-extensions.cfg')
+        with open(confpath, 'w') as f:
+            f.write('enable=1\n')  # No section header.
+        conf.defaultCfg['foo'] = config.IdleConfParser('')  # Empty, valid.
+        conf.userCfg['foo'] = config.IdleUserConfParser(confpath)
+
+        self.assertIsNone(conf.file_load_error_message())
+        conf.LoadCfgFiles()  # Must not raise.
+
+        self.assertEqual(len(conf.file_load_errors), 1)
+        file, err = conf.file_load_errors[0]
+        self.assertEqual(file, confpath)
+        # The bad file is moved aside, not left to be overwritten or deleted.
+        self.assertFalse(os.path.exists(confpath))
+        with open(confpath + '.bad') as f:
+            self.assertEqual(f.read(), 'enable=1\n')
+        message = conf.file_load_error_message()
+        self.assertIn(confpath, message)
+        self.assertIn('MissingSectionHeaderError', message)
+
+    def test_load_cfg_files_bad_encoding(self):
+        # gh-66172: a file that is not valid UTF-8 is handled like a bad parse.
+        conf = self.new_config(_utest=True)
+        tmpdir = tempfile.TemporaryDirectory()
+        self.addCleanup(tmpdir.cleanup)
+        confpath = os.path.join(tmpdir.name, 'config-main.cfg')
+        with open(confpath, 'wb') as f:
+            f.write(b'[Section]\nkey = \xff\n')  # Invalid UTF-8.
+        conf.defaultCfg['foo'] = config.IdleConfParser('')  # Empty, valid.
+        conf.userCfg['foo'] = config.IdleUserConfParser(confpath)
+
+        conf.LoadCfgFiles()  # Must not raise.
+
+        self.assertEqual(len(conf.file_load_errors), 1)
+        self.assertIsInstance(conf.file_load_errors[0][1], UnicodeDecodeError)
+        self.assertFalse(os.path.exists(confpath))
+        self.assertTrue(os.path.exists(confpath + '.bad'))
+
     def test_save_user_cfg_files(self):
         conf = self.mock_config()
 

Lib/idlelib/pyshell.py

@@ -1612,6 +1612,12 @@ def main():
     root.withdraw()
     fix_scaling(root)
 
+    # Warn about configuration files that could not be parsed (gh-66172).
+    config_error = idleConf.file_load_error_message()
+    if config_error:
+        messagebox.showwarning('IDLE Configuration Warning', config_error,
+                               parent=root)
+
     # set application icon
     icondir = os.path.join(os.path.dirname(__file__), 'Icons')
     if system() == 'Windows':

Lib/test/test_nturl2path.py

@@ -1,7 +1,9 @@
+import os
 import sys
 import unittest
 import urllib.parse
 
+from test.support import os_helper
 from test.support import warnings_helper
 
 
@@ -36,7 +38,6 @@ def test_pathname2url(self):
         self.assertEqual(fn('C:\\a\\b.c\\'), '///C:/a/b.c/')
         self.assertEqual(fn('C:\\a\\\\b.c'), '///C:/a//b.c')
         self.assertEqual(fn('C:\\a\\b%#c'), '///C:/a/b%25%23c')
-        self.assertEqual(fn('C:\\a\\b\xe9'), '///C:/a/b%C3%A9')
         self.assertEqual(fn('C:\\foo\\bar\\spam.foo'), "///C:/foo/bar/spam.foo")
         # NTFS alternate data streams
         self.assertEqual(fn('C:\\foo:bar'), '///C:/foo%3Abar')
@@ -47,7 +48,7 @@ def test_pathname2url(self):
         self.assertEqual(fn("\\\\\\folder\\test\\"), '///folder/test/')
         self.assertEqual(fn('\\\\some\\share\\'), '//some/share/')
         self.assertEqual(fn('\\\\some\\share\\a\\b.c'), '//some/share/a/b.c')
-        self.assertEqual(fn('\\\\some\\share\\a\\b%#c\xe9'), '//some/share/a/b%25%23c%C3%A9')
+        self.assertEqual(fn('\\\\some\\share\\a\\b%#c'), '//some/share/a/b%25%23c')
         # Alternate path separator
         self.assertEqual(fn('C:/a/b.c'), '///C:/a/b.c')
         self.assertEqual(fn('//some/share/a/b.c'), '//some/share/a/b.c')
@@ -60,14 +61,28 @@ def test_pathname2url(self):
         for url in urls:
             self.assertEqual(fn(nturl2path.url2pathname(url)), url)
 
+    @unittest.skipUnless(os_helper.FS_NONASCII, 'need os_helper.FS_NONASCII')
+    def test_pathname2url_nonascii(self):
+        encoding = sys.getfilesystemencoding()
+        errors = sys.getfilesystemencodeerrors()
+        char = os_helper.FS_NONASCII
+        quoted = urllib.parse.quote(char, encoding=encoding, errors=errors)
+        self.assertEqual(nturl2path.pathname2url(f'C:\\a\\b{char}'),
+                         '///C:/a/b' + quoted)
+        self.assertEqual(nturl2path.pathname2url(f'\\\\some\\share\\a\\b{char}'),
+                         '//some/share/a/b' + quoted)
+
+    @unittest.skipUnless(os_helper.TESTFN_UNDECODABLE,
+                         'need os_helper.TESTFN_UNDECODABLE')
     def test_pathname2url_surrogates(self):
         # gh-156713: the filesystem encoding and error handler are used,
         # so that paths containing surrogate characters can be converted.
         encoding = sys.getfilesystemencoding()
         errors = sys.getfilesystemencodeerrors()
-        tail = urllib.parse.quote('a\udcff', encoding=encoding, errors=errors)
-        self.assertEqual(nturl2path.pathname2url('C:\\a\udcff'),
-                         '///C:/' + tail)
+        path = os.fsdecode(os_helper.TESTFN_UNDECODABLE)
+        url = urllib.parse.quote(path, encoding=encoding, errors=errors)
+        self.assertEqual(nturl2path.pathname2url('C:\\' + path),
+                         '///C:/' + url)
 
     def test_url2pathname(self):
         fn = nturl2path.url2pathname
@@ -114,14 +129,17 @@ def test_url2pathname(self):
             self.assertEqual(fn(nturl2path.pathname2url(path)), path)
 
 
+    @unittest.skipUnless(os_helper.TESTFN_UNDECODABLE,
+                         'need os_helper.TESTFN_UNDECODABLE')
     def test_url2pathname_surrogates(self):
         # gh-156713: the filesystem encoding and error handler are used, so
         # that URLs containing percent-encoded surrogates can be converted.
         encoding = sys.getfilesystemencoding()
         errors = sys.getfilesystemencodeerrors()
-        url = urllib.parse.quote('a\udcff', encoding=encoding, errors=errors)
+        path = os.fsdecode(os_helper.TESTFN_UNDECODABLE)
+        url = urllib.parse.quote(path, encoding=encoding, errors=errors)
         self.assertEqual(nturl2path.url2pathname('///C:/' + url),
-                         'C:\\a\udcff')
+                         'C:\\' + path)
 
 
 if __name__ == '__main__':

Misc/NEWS.d/next/IDLE/2026-07-01-13-30-00.gh-issue-66172.Qm4xR7.rst

@@ -0,0 +1,3 @@
+IDLE no longer fails to start when a user configuration file is corrupt.
+The unparsable file is renamed with a ".bad" suffix, default settings are
+used instead, and a warning lists the affected files.