Merge pull request #13510 from gousaiyang/fix-3-10-encoding-warning

Fix EncodingWarning on Python 3.10

.github/workflows/downstream.yml

@@ -41,7 +41,7 b' jobs:'
         python -m pip install --upgrade -e file://$PWD#egg=ipython[test]
         # we must instal IPython after ipykernel to get the right versions.
         python -m pip install --upgrade --upgrade-strategy eager flaky ipyparallel
-        python -m pip install --upgrade pytest 
+        python -m pip install --upgrade 'pytest<7' 
     - name: pytest
       env:
         COLUMNS: 120

IPython/core/application.py

@@ -470,7 +470,7 b' class BaseIPythonApplication(Application):'
         config_file = Path(self.profile_dir.location) / self.config_file_name
         if self.overwrite or not config_file.exists():
             self.log.warning("Generating default config file: %r" % (config_file))
-            config_file.write_text(s)
+            config_file.write_text(s, encoding="utf-8")
 
     @catch_config_error
     def initialize(self, argv=None):

IPython/core/crashhandler.py

@@ -185,7 +185,7 b' class CrashHandler(object):'
 
         # and generate a complete report on disk
         try:
-            report = open(report_name,'w')
+            report = open(report_name, "w", encoding="utf-8")
         except:
             print('Could not create crash report on disk.', file=sys.stderr)
             return

IPython/core/display.py

@@ -349,7 +349,8 b' class DisplayObject(object):'
     def reload(self):
         """Reload the raw data from file or URL."""
         if self.filename is not None:
-            with open(self.filename, self._read_flags) as f:
+            encoding = None if "b" in self._read_flags else "utf-8"
+            with open(self.filename, self._read_flags, encoding=encoding) as f:
                 self.data = f.read()
         elif self.url is not None:
             # Deferred import
@@ -369,7 +370,11 b' class DisplayObject(object):'
                 if 'gzip' in response.headers['content-encoding']:
                     import gzip
                     from io import BytesIO
-                    with gzip.open(BytesIO(data), 'rt', encoding=encoding) as fp:
+
+                    # assume utf-8 if encoding is not specified
+                    with gzip.open(
+                        BytesIO(data), "rt", encoding=encoding or "utf-8"
+                    ) as fp:
                         encoding = None
                         data = fp.read()
 

IPython/core/interactiveshell.py

@@ -2667,7 +2667,7 b' class InteractiveShell(SingletonConfigurable):'
 
         # Make sure we can open the file
         try:
-            with fname.open():
+            with fname.open("rb"):
                 pass
         except:
             warn('Could not open file <%s> for safe execution.' % fname)
@@ -2725,7 +2725,7 b' class InteractiveShell(SingletonConfigurable):'
 
         # Make sure we can open the file
         try:
-            with fname.open():
+            with fname.open("rb"):
                 pass
         except:
             warn('Could not open file <%s> for safe execution.' % fname)
@@ -2747,7 +2747,7 b' class InteractiveShell(SingletonConfigurable):'
                     if cell.cell_type == 'code':
                         yield cell.source
             else:
-                yield fname.read_text()
+                yield fname.read_text(encoding="utf-8")
 
         with prepended_to_syspath(dname):
             try:
@@ -3499,7 +3499,7 b' class InteractiveShell(SingletonConfigurable):'
         self.tempfiles.append(file_path)
 
         if data:
-            file_path.write_text(data)
+            file_path.write_text(data, encoding="utf-8")
         return filename
 
     def ask_yes_no(self, prompt, default=None, interrupt=None):

IPython/core/magics/code.py

@@ -538,7 +538,7 b' class CodeMagics(Magics):'
         self.shell.hooks.editor(filename)
 
         # and make a new macro object, to replace the old one
-        mvalue = Path(filename).read_text()
+        mvalue = Path(filename).read_text(encoding="utf-8")
         self.shell.user_ns[mname] = Macro(mvalue)
 
     @skip_doctest
@@ -728,7 +728,7 b' class CodeMagics(Magics):'
         # XXX TODO: should this be generalized for all string vars?
         # For now, this is special-cased to blocks created by cpaste
         if args.strip() == "pasted_block":
-            self.shell.user_ns["pasted_block"] = filepath.read_text()
+            self.shell.user_ns["pasted_block"] = filepath.read_text(encoding="utf-8")
 
         if 'x' in opts:  # -x prevents actual execution
             print()
@@ -736,9 +736,9 b' class CodeMagics(Magics):'
             print('done. Executing edited code...')
             with preserve_keys(self.shell.user_ns, '__file__'):
                 if not is_temp:
-                    self.shell.user_ns['__file__'] = filename
-                if 'r' in opts:    # Untranslated IPython code
-                    source = filepath.read_text()
+                    self.shell.user_ns["__file__"] = filename
+                if "r" in opts:  # Untranslated IPython code
+                    source = filepath.read_text(encoding="utf-8")
                     self.shell.run_cell(source, store_history=False)
                 else:
                     self.shell.safe_execfile(filename, self.shell.user_ns,
@@ -746,7 +746,7 b' class CodeMagics(Magics):'
 
         if is_temp:
             try:
-                return filepath.read_text()
+                return filepath.read_text(encoding="utf-8")
             except IOError as msg:
                 if Path(msg.filename) == filepath:
                     warn('File not found. Did you forget to save?')

IPython/core/magics/execution.py

@@ -360,7 +360,7 b' class ExecutionMagics(Magics):'
         if text_file:
             pfile = Path(text_file)
             pfile.touch(exist_ok=True)
-            pfile.write_text(output)
+            pfile.write_text(output, encoding="utf-8")
 
             print(
                 f"\n*** Profile printout saved to text file {repr(text_file)}.{sys_exit}"

IPython/core/magics/packaging.py

@@ -32,7 +32,7 b' def _get_conda_executable():'
 
     # Otherwise, attempt to extract the executable from conda history.
     # This applies in any conda environment.
-    history = Path(sys.prefix, "conda-meta", "history").read_text()
+    history = Path(sys.prefix, "conda-meta", "history").read_text(encoding="utf-8")
     match = re.search(
         r"^#\s*cmd:\s*(?P<command>.*conda)\s[create|install]",
         history,

IPython/core/page.py

@@ -199,7 +199,7 b' def pager_page(strng, start=0, screen_lines=0, pager_cmd=None):'
                 tmppath = Path(tmpname)
                 try:
                     os.close(fd)
-                    with tmppath.open("wt") as tmpfile:
+                    with tmppath.open("wt", encoding="utf-8") as tmpfile:
                         tmpfile.write(strng)
                         cmd = "%s < %s" % (pager_cmd, tmppath)
                     # tmpfile needs to be closed for windows
@@ -213,12 +213,15 b' def pager_page(strng, start=0, screen_lines=0, pager_cmd=None):'
             try:
                 retval = None
                 # Emulate os.popen, but redirect stderr
-                proc = subprocess.Popen(pager_cmd,
-                                shell=True,
-                                stdin=subprocess.PIPE,
-                                stderr=subprocess.DEVNULL
-                                )
-                pager = os._wrap_close(io.TextIOWrapper(proc.stdin), proc)
+                proc = subprocess.Popen(
+                    pager_cmd,
+                    shell=True,
+                    stdin=subprocess.PIPE,
+                    stderr=subprocess.DEVNULL,
+                )
+                pager = os._wrap_close(
+                    io.TextIOWrapper(proc.stdin, encoding="utf-8"), proc
+                )
                 try:
                     pager_encoding = pager.encoding or sys.stdout.encoding
                     pager.write(strng)
@@ -277,7 +280,7 b' def page_file(fname, start=0, pager_cmd=None):'
         try:
             if start > 0:
                 start -= 1
-            page(open(fname).read(),start)
+            page(open(fname, encoding="utf-8").read(), start)
         except:
             print('Unable to show file',repr(fname))
 

IPython/core/tests/test_application.py

@@ -34,7 +34,7 b' def test_unicode_ipdir():'
     ipdir = tempfile.mkdtemp(suffix=u"€")
     
     # Create the config file, so it tries to load it.
-    with open(os.path.join(ipdir, 'ipython_config.py'), "w") as f:
+    with open(os.path.join(ipdir, "ipython_config.py"), "w", encoding="utf-8") as f:
         pass
     
     old_ipdir1 = os.environ.pop("IPYTHONDIR", None)
@@ -59,7 +59,7 b' def test_cli_priority():'
             test = Unicode().tag(config=True)
 
         # Create the config file, so it tries to load it.
-        with open(os.path.join(td, 'ipython_config.py'), "w") as f:
+        with open(os.path.join(td, "ipython_config.py"), "w", encoding="utf-8") as f:
             f.write("c.TestApp.test = 'config file'")
 
         app = TestApp()

IPython/core/tests/test_completer.py

@@ -346,7 +346,7 b' class TestCompleter(unittest.TestCase):'
             suffixes = ["1", "2"]
             names = [prefix + s for s in suffixes]
             for n in names:
-                open(n, "w").close()
+                open(n, "w", encoding="utf-8").close()
 
             # Check simple completion
             c = ip.complete(prefix)[1]
@@ -365,7 +365,7 b' class TestCompleter(unittest.TestCase):'
             suffixes = ["1", "2"]
             names = [prefix + s for s in suffixes]
             for n in names:
-                open(n, "w").close()
+                open(n, "w", encoding="utf-8").close()
 
             # Check simple completion
             c = ip.complete(prefix)[1]
@@ -381,7 +381,7 b' class TestCompleter(unittest.TestCase):'
         ip = get_ipython()
         with TemporaryWorkingDirectory():
             name = "foo'bar"
-            open(name, "w").close()
+            open(name, "w", encoding="utf-8").close()
 
             # Don't escape Windows
             escaped = name if sys.platform == "win32" else "foo\\'bar"

IPython/core/tests/test_completerlib.py

@@ -33,7 +33,7 b' class Test_magic_run_completer(unittest.TestCase):'
     def setUp(self):
         self.BASETESTDIR = tempfile.mkdtemp()
         for fil in self.files:
-            with open(join(self.BASETESTDIR, fil), "w") as sfile:
+            with open(join(self.BASETESTDIR, fil), "w", encoding="utf-8") as sfile:
                 sfile.write("pass\n")
         for d in self.dirs:
             os.mkdir(join(self.BASETESTDIR, d))
@@ -89,7 +89,7 b' class Test_magic_run_completer_nonascii(unittest.TestCase):'
     def setUp(self):
         self.BASETESTDIR = tempfile.mkdtemp()
         for fil in [u"aaø.py", u"a.py", u"b.py"]:
-            with open(join(self.BASETESTDIR, fil), "w") as sfile:
+            with open(join(self.BASETESTDIR, fil), "w", encoding="utf-8") as sfile:
                 sfile.write("pass\n")
         self.oldpath = os.getcwd()
         os.chdir(self.BASETESTDIR)
@@ -133,8 +133,8 b' def test_import_invalid_module():'
     with TemporaryDirectory() as tmpdir:
         sys.path.insert( 0, tmpdir )
         for name in invalid_module_names | valid_module_names:
-            filename = os.path.join(tmpdir, name + '.py')
-            open(filename, 'w').close()
+            filename = os.path.join(tmpdir, name + ".py")
+            open(filename, "w", encoding="utf-8").close()
 
         s = set( module_completion('import foo') )
         intersection = s.intersection(invalid_module_names)

IPython/core/tests/test_extension.py

@@ -26,12 +26,12 b' def load_ipython_extension(ip):'
 def test_extension_loading():
     em = get_ipython().extension_manager
     with TemporaryDirectory() as td:
-        ext1 = os.path.join(td, 'ext1.py')
-        with open(ext1, 'w') as f:
+        ext1 = os.path.join(td, "ext1.py")
+        with open(ext1, "w", encoding="utf-8") as f:
             f.write(ext1_content)
-        
-        ext2 = os.path.join(td, 'ext2.py')
-        with open(ext2, 'w') as f:
+
+        ext2 = os.path.join(td, "ext2.py")
+        with open(ext2, "w", encoding="utf-8") as f:
             f.write(ext2_content)
         
         with prepended_to_syspath(td):
@@ -76,8 +76,8 b' def test_extension_loading():'
 def test_extension_builtins():
     em = get_ipython().extension_manager
     with TemporaryDirectory() as td:
-        ext3 = os.path.join(td, 'ext3.py')
-        with open(ext3, 'w') as f:
+        ext3 = os.path.join(td, "ext3.py")
+        with open(ext3, "w", encoding="utf-8") as f:
             f.write(ext3_content)
         
         assert 'ext3' not in em.loaded

IPython/core/tests/test_interactiveshell.py

@@ -485,12 +485,12 b' class InteractiveShellTestCase(unittest.TestCase):'
     def test_mktempfile(self):
         filename = ip.mktempfile()
         # Check that we can open the file again on Windows
-        with open(filename, 'w') as f:
-            f.write('abc')
+        with open(filename, "w", encoding="utf-8") as f:
+            f.write("abc")
 
-        filename = ip.mktempfile(data='blah')
-        with open(filename, 'r') as f:
-            self.assertEqual(f.read(), 'blah')
+        filename = ip.mktempfile(data="blah")
+        with open(filename, "r", encoding="utf-8") as f:
+            self.assertEqual(f.read(), "blah")
 
     def test_new_main_mod(self):
         # Smoketest to check that this accepts a unicode module name
@@ -545,7 +545,9 b' class TestSafeExecfileNonAsciiPath(unittest.TestCase):'
         self.BASETESTDIR = tempfile.mkdtemp()
         self.TESTDIR = join(self.BASETESTDIR, u"åäö")
         os.mkdir(self.TESTDIR)
-        with open(join(self.TESTDIR, u"åäötestscript.py"), "w") as sfile:
+        with open(
+            join(self.TESTDIR, u"åäötestscript.py"), "w", encoding="utf-8"
+        ) as sfile:
             sfile.write("pass\n")
         self.oldpath = os.getcwd()
         os.chdir(self.TESTDIR)

IPython/core/tests/test_magic.py

@@ -863,12 +863,18 b' def test_file():'
     """Basic %%writefile"""
     ip = get_ipython()
     with TemporaryDirectory() as td:
-        fname = os.path.join(td, 'file1')
-        ip.run_cell_magic("writefile", fname, u'\n'.join([
-            'line1',
-            'line2',
-        ]))
-        s = Path(fname).read_text()
+        fname = os.path.join(td, "file1")
+        ip.run_cell_magic(
+            "writefile",
+            fname,
+            "\n".join(
+                [
+                    "line1",
+                    "line2",
+                ]
+            ),
+        )
+        s = Path(fname).read_text(encoding="utf-8")
         assert "line1\n" in s
         assert "line2" in s
 
@@ -878,12 +884,18 b' def test_file_single_quote():'
     """Basic %%writefile with embedded single quotes"""
     ip = get_ipython()
     with TemporaryDirectory() as td:
-        fname = os.path.join(td, '\'file1\'')
-        ip.run_cell_magic("writefile", fname, u'\n'.join([
-            'line1',
-            'line2',
-        ]))
-        s = Path(fname).read_text()
+        fname = os.path.join(td, "'file1'")
+        ip.run_cell_magic(
+            "writefile",
+            fname,
+            "\n".join(
+                [
+                    "line1",
+                    "line2",
+                ]
+            ),
+        )
+        s = Path(fname).read_text(encoding="utf-8")
         assert "line1\n" in s
         assert "line2" in s
 
@@ -894,11 +906,17 b' def test_file_double_quote():'
     ip = get_ipython()
     with TemporaryDirectory() as td:
         fname = os.path.join(td, '"file1"')
-        ip.run_cell_magic("writefile", fname, u'\n'.join([
-            'line1',
-            'line2',
-        ]))
-        s = Path(fname).read_text()
+        ip.run_cell_magic(
+            "writefile",
+            fname,
+            "\n".join(
+                [
+                    "line1",
+                    "line2",
+                ]
+            ),
+        )
+        s = Path(fname).read_text(encoding="utf-8")
         assert "line1\n" in s
         assert "line2" in s
 
@@ -907,13 +925,19 b' def test_file_var_expand():'
     """%%writefile $filename"""
     ip = get_ipython()
     with TemporaryDirectory() as td:
-        fname = os.path.join(td, 'file1')
-        ip.user_ns['filename'] = fname
-        ip.run_cell_magic("writefile", '$filename', u'\n'.join([
-            'line1',
-            'line2',
-        ]))
-        s = Path(fname).read_text()
+        fname = os.path.join(td, "file1")
+        ip.user_ns["filename"] = fname
+        ip.run_cell_magic(
+            "writefile",
+            "$filename",
+            "\n".join(
+                [
+                    "line1",
+                    "line2",
+                ]
+            ),
+        )
+        s = Path(fname).read_text(encoding="utf-8")
         assert "line1\n" in s
         assert "line2" in s
 
@@ -937,16 +961,28 b' def test_file_amend():'
     """%%writefile -a amends files"""
     ip = get_ipython()
     with TemporaryDirectory() as td:
-        fname = os.path.join(td, 'file2')
-        ip.run_cell_magic("writefile", fname, u'\n'.join([
-            'line1',
-            'line2',
-        ]))
-        ip.run_cell_magic("writefile", "-a %s" % fname, u'\n'.join([
-            'line3',
-            'line4',
-        ]))
-        s = Path(fname).read_text()
+        fname = os.path.join(td, "file2")
+        ip.run_cell_magic(
+            "writefile",
+            fname,
+            "\n".join(
+                [
+                    "line1",
+                    "line2",
+                ]
+            ),
+        )
+        ip.run_cell_magic(
+            "writefile",
+            "-a %s" % fname,
+            "\n".join(
+                [
+                    "line3",
+                    "line4",
+                ]
+            ),
+        )
+        s = Path(fname).read_text(encoding="utf-8")
         assert "line1\n" in s
         assert "line3\n" in s
 
@@ -956,11 +992,17 b' def test_file_spaces():'
     ip = get_ipython()
     with TemporaryWorkingDirectory() as td:
         fname = "file name"
-        ip.run_cell_magic("file", '"%s"'%fname, u'\n'.join([
-            'line1',
-            'line2',
-        ]))
-        s = Path(fname).read_text()
+        ip.run_cell_magic(
+            "file",
+            '"%s"' % fname,
+            "\n".join(
+                [
+                    "line1",
+                    "line2",
+                ]
+            ),
+        )
+        s = Path(fname).read_text(encoding="utf-8")
         assert "line1\n" in s
         assert "line2" in s
 
@@ -1156,11 +1198,11 b' def test_save():'
     with TemporaryDirectory() as tmpdir:
         file = os.path.join(tmpdir, "testsave.py")
         ip.run_line_magic("save", "%s 1-10" % file)
-        content = Path(file).read_text()
+        content = Path(file).read_text(encoding="utf-8")
         assert content.count(cmds[0]) == 1
         assert "coding: utf-8" in content
         ip.run_line_magic("save", "-a %s 1-10" % file)
-        content = Path(file).read_text()
+        content = Path(file).read_text(encoding="utf-8")
         assert content.count(cmds[0]) == 2
         assert "coding: utf-8" in content
 
@@ -1175,7 +1217,7 b' def test_save_with_no_args():'
     with TemporaryDirectory() as tmpdir:
         path = os.path.join(tmpdir, "testsave.py")
         ip.run_line_magic("save", path)
-        content = Path(path).read_text()
+        content = Path(path).read_text(encoding="utf-8")
         expected_content = dedent(
             """\
             # coding: utf-8
@@ -1377,8 +1419,8 b' if __name__ == "__main__":'
 def test_run_module_from_import_hook():
     "Test that a module can be loaded via an import hook"
     with TemporaryDirectory() as tmpdir:
-        fullpath = os.path.join(tmpdir, 'my_tmp.py')
-        Path(fullpath).write_text(TEST_MODULE)
+        fullpath = os.path.join(tmpdir, "my_tmp.py")
+        Path(fullpath).write_text(TEST_MODULE, encoding="utf-8")
 
         import importlib.abc
         import importlib.util
@@ -1394,7 +1436,7 b' def test_run_module_from_import_hook():'
 
             def get_data(self, path):
                 assert Path(path).samefile(fullpath)
-                return Path(fullpath).read_text()
+                return Path(fullpath).read_text(encoding="utf-8")
 
         sys.meta_path.insert(0, MyTempImporter())
 

IPython/core/tests/test_profile.py

@@ -84,10 +84,10 b' class ProfileStartupTest(TestCase):'
 
     def init(self, startup_file, startup, test):
         # write startup python file
-        with open(Path(self.pd.startup_dir) / startup_file, "w") as f:
+        with open(Path(self.pd.startup_dir) / startup_file, "w", encoding="utf-8") as f:
             f.write(startup)
         # write simple test file, to check that the startup file was run
-        with open(self.fname, 'w') as f:
+        with open(self.fname, "w", encoding="utf-8") as f:
             f.write(test)
 
     def validate(self, output):
@@ -111,7 +111,7 b' def test_list_profiles_in():'
     if dec.unicode_paths:
         Path(td / u"profile_ünicode").mkdir(parents=True)
 
-    with open(td / "profile_file", "w") as f:
+    with open(td / "profile_file", "w", encoding="utf-8") as f:
         f.write("I am not a profile directory")
     profiles = list_profiles_in(td)
 

IPython/core/tests/test_run.py

@@ -64,7 +64,7 b' def doctest_run_builtins():'
 
     In [3]: fname = tempfile.mkstemp('.py')[1]
 
-    In [3]: f = open(fname,'w')
+    In [3]: f = open(fname, 'w', encoding='utf-8')
 
     In [4]: dummy= f.write('pass\n')
 
@@ -443,7 +443,7 b' class TestMagicRunWithPackage(unittest.TestCase):'
         d = os.path.dirname(path)
         if not os.path.isdir(d):
             os.makedirs(d)
-        with open(path, 'w') as f:
+        with open(path, "w", encoding="utf-8") as f:
             f.write(textwrap.dedent(content))
 
     def setUp(self):
@@ -526,8 +526,8 b' class TestMagicRunWithPackage(unittest.TestCase):'
 
 def test_run__name__():
     with TemporaryDirectory() as td:
-        path = pjoin(td, 'foo.py')
-        with open(path, 'w') as f:
+        path = pjoin(td, "foo.py")
+        with open(path, "w", encoding="utf-8") as f:
             f.write("q = __name__")
 
         _ip.user_ns.pop("q", None)
@@ -547,15 +547,19 b' def test_run__name__():'
 def test_run_tb():
     """Test traceback offset in %run"""
     with TemporaryDirectory() as td:
-        path = pjoin(td, 'foo.py')
-        with open(path, 'w') as f:
-            f.write('\n'.join([
-                "def foo():",
-                "    return bar()",
-                "def bar():",
-                "    raise RuntimeError('hello!')",
-                "foo()",
-            ]))
+        path = pjoin(td, "foo.py")
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(
+                "\n".join(
+                    [
+                        "def foo():",
+                        "    return bar()",
+                        "def bar():",
+                        "    raise RuntimeError('hello!')",
+                        "foo()",
+                    ]
+                )
+            )
         with capture_output() as io:
             _ip.magic('run {}'.format(path))
         out = io.stdout
@@ -577,8 +581,8 b' def test_multiprocessing_run():'
         mpm = sys.modules.get('__mp_main__')
         sys.modules['__mp_main__'] = None
         try:
-            path = pjoin(td, 'test.py')
-            with open(path, 'w') as f:
+            path = pjoin(td, "test.py")
+            with open(path, "w", encoding="utf-8") as f:
                 f.write("import multiprocessing\nprint('hoy')")
             with capture_output() as io:
                 _ip.run_line_magic('run', path)
@@ -597,15 +601,19 b' def test_multiprocessing_run():'
 def test_script_tb():
     """Test traceback offset in `ipython script.py`"""
     with TemporaryDirectory() as td:
-        path = pjoin(td, 'foo.py')
-        with open(path, 'w') as f:
-            f.write('\n'.join([
-                "def foo():",
-                "    return bar()",
-                "def bar():",
-                "    raise RuntimeError('hello!')",
-                "foo()",
-            ]))
+        path = pjoin(td, "foo.py")
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(
+                "\n".join(
+                    [
+                        "def foo():",
+                        "    return bar()",
+                        "def bar():",
+                        "    raise RuntimeError('hello!')",
+                        "foo()",
+                    ]
+                )
+            )
         out, err = tt.ipexec(path)
         assert "execfile" not in out
         assert "RuntimeError" in out

IPython/core/tests/test_ultratb.py

@@ -58,7 +58,7 b' class ChangedPyFileTest(unittest.TestCase):'
         """
         with TemporaryDirectory() as td:
             fname = os.path.join(td, "foo.py")
-            with open(fname, "w") as f:
+            with open(fname, "w", encoding="utf-8") as f:
                 f.write(file_1)
             
             with prepended_to_syspath(td):
@@ -68,7 +68,7 b' class ChangedPyFileTest(unittest.TestCase):'
                 ip.run_cell("foo.f()")
             
             # Make the file shorter, so the line of the error is missing.
-            with open(fname, "w") as f:
+            with open(fname, "w", encoding="utf-8") as f:
                 f.write(file_2)
             
             # For some reason, this was failing on the *second* call after
@@ -92,7 +92,7 b' class NonAsciiTest(unittest.TestCase):'
         # Non-ascii directory name as well.
         with TemporaryDirectory(suffix=u'é') as td:
             fname = os.path.join(td, u"fooé.py")
-            with open(fname, "w") as f:
+            with open(fname, "w", encoding="utf-8") as f:
                 f.write(file_1)
             
             with prepended_to_syspath(td):
@@ -172,7 +172,7 b' class IndentationErrorTest(unittest.TestCase):'
         
         with TemporaryDirectory() as td:
             fname = os.path.join(td, "foo.py")
-            with open(fname, "w") as f:
+            with open(fname, "w", encoding="utf-8") as f:
                 f.write(indentationerror_file)
             
             with tt.AssertPrints("IndentationError"):
@@ -221,14 +221,14 b' bar()'
     def test_changing_py_file(self):
         with TemporaryDirectory() as td:
             fname = os.path.join(td, "foo.py")
-            with open(fname, 'w') as f:
+            with open(fname, "w", encoding="utf-8") as f:
                 f.write(se_file_1)
 
             with tt.AssertPrints(["7/", "SyntaxError"]):
                 ip.magic("run " + fname)
 
             # Modify the file
-            with open(fname, 'w') as f:
+            with open(fname, "w", encoding="utf-8") as f:
                 f.write(se_file_2)
 
             # The SyntaxError should point to the correct line

IPython/extensions/storemagic.py

@@ -176,12 +176,12 b' class StoreMagics(Magics):'
         # default action - store the variable
         else:
             # %store foo >file.txt or >>file.txt
-            if len(args) > 1 and args[1].startswith('>'):
-                fnam = os.path.expanduser(args[1].lstrip('>').lstrip())
-                if args[1].startswith('>>'):
-                    fil = open(fnam, 'a')
+            if len(args) > 1 and args[1].startswith(">"):
+                fnam = os.path.expanduser(args[1].lstrip(">").lstrip())
+                if args[1].startswith(">>"):
+                    fil = open(fnam, "a", encoding="utf-8")
                 else:
-                    fil = open(fnam, 'w')
+                    fil = open(fnam, "w", encoding="utf-8")
                 with fil:
                     obj = ip.ev(args[0])
                     print("Writing '%s' (%s) to file '%s'." % (args[0],

IPython/extensions/tests/test_autoreload.py

@@ -119,13 +119,13 b' class Fixture(TestCase):'
         time.sleep(1.05)
 
         # Write
-        with open(filename, "w") as f:
+        with open(filename, "w", encoding="utf-8") as f:
             f.write(content)
 
     def new_module(self, code):
         code = textwrap.dedent(code)
         mod_name, mod_fn = self.get_module()
-        with open(mod_fn, "w") as f:
+        with open(mod_fn, "w", encoding="utf-8") as f:
             f.write(code)
         return mod_name, mod_fn
 

IPython/lib/demo.py

@@ -405,7 +405,7 b' class Demo(object):'
 
         filename = self.shell.mktempfile(self.src_blocks[index])
         self.shell.hooks.editor(filename, 1)
-        with open(Path(filename), "r") as f:
+        with open(Path(filename), "r", encoding="utf-8") as f:
             new_block = f.read()
         # update the source and colored block
         self.src_blocks[index] = new_block

IPython/lib/tests/test_deepreload.py

@@ -19,9 +19,9 b' def test_deepreload():'
     with TemporaryDirectory() as tmpdir:
         with prepended_to_syspath(tmpdir):
             tmpdirpath = Path(tmpdir)
-            with open(tmpdirpath / "A.py", "w") as f:
+            with open(tmpdirpath / "A.py", "w", encoding="utf-8") as f:
                 f.write("class Object:\n    pass\nok = True\n")
-            with open(tmpdirpath / "B.py", "w") as f:
+            with open(tmpdirpath / "B.py", "w", encoding="utf-8") as f:
                 f.write("import A\nassert A.ok, 'we are fine'\n")
             import A
             import B

IPython/testing/tests/test_tools.py

@@ -62,7 +62,7 b' def test_temp_pyfile():'
     src = 'pass\n'
     fname = tt.temp_pyfile(src)
     assert os.path.isfile(fname)
-    with open(fname) as fh2:
+    with open(fname, encoding="utf-8") as fh2:
         src2 = fh2.read()
     assert src2 == src
 

IPython/testing/tools.py

@@ -426,9 +426,8 b' def mute_warn():'
 
 @contextmanager
 def make_tempfile(name):
-    """ Create an empty, named, temporary file for the duration of the context.
-    """
-    open(name, 'w').close()
+    """Create an empty, named, temporary file for the duration of the context."""
+    open(name, "w", encoding="utf-8").close()
     try:
         yield
     finally:

IPython/tests/cve.py

@@ -33,7 +33,9 b' def test_cve_2022_21699():'
 
     with TemporaryWorkingDirectory() as t:
         dangerous_startup_dir.mkdir(parents=True)
-        (dangerous_startup_dir / "foo.py").write_text(f'print("{dangerous_expected}")')
+        (dangerous_startup_dir / "foo.py").write_text(
+            f'print("{dangerous_expected}")', encoding="utf-8"
+        )
         # 1 sec to make sure FS is flushed.
         # time.sleep(1)
         cmd = [sys.executable, "-m", "IPython"]

IPython/utils/io.py

@@ -20,7 +20,7 b' from IPython.utils.decorators import undoc'
 from .capture import CapturedIO, capture_output
 
 # setup stdin/stdout/stderr to sys.stdin/sys.stdout/sys.stderr
-devnull = open(os.devnull, 'w')
+devnull = open(os.devnull, "w", encoding="utf-8")
 atexit.register(devnull.close)
 
 
@@ -52,7 +52,8 b' class Tee(object):'
         if hasattr(file_or_name, 'write') and hasattr(file_or_name, 'seek'):
             self.file = file_or_name
         else:
-            self.file = open(file_or_name, mode)
+            encoding = None if "b" in mode else "utf-8"
+            self.file = open(file_or_name, mode, encoding=encoding)
         self.channel = channel
         self.ostream = getattr(sys, channel)
         setattr(sys, channel, self)
@@ -131,7 +132,7 b" def temp_pyfile(src, ext='.py'):"
         It is the caller's responsibility to close the open file and unlink it.
     """
     fname = tempfile.mkstemp(ext)[1]
-    with open(Path(fname), "w") as f:
+    with open(Path(fname), "w", encoding="utf-8") as f:
         f.write(src)
         f.flush()
     return fname

IPython/utils/tempdir.py

@@ -24,7 +24,8 b' class NamedFileInTemporaryDirectory(object):'
         """
         self._tmpdir = TemporaryDirectory(**kwds)
         path = Path(self._tmpdir.name) / filename
-        self.file = open(path, mode, bufsize)
+        encoding = None if "b" in mode else "utf-8"
+        self.file = open(path, mode, bufsize, encoding=encoding)
 
     def cleanup(self):
         self.file.close()

IPython/utils/tests/test_module_paths.py

@@ -32,7 +32,7 b' TMP_TEST_DIR = Path(tempfile.mkdtemp(suffix="with.dot"))'
 old_syspath = sys.path
 
 def make_empty_file(fname):
-    open(fname, 'w').close()
+    open(fname, "w", encoding="utf-8").close()
 
 
 def setup_module():

IPython/utils/tests/test_path.py

@@ -295,7 +295,7 b' class TestRaiseDeprecation(unittest.TestCase):'
         ipdir = os.path.join(tmpdir, '.ipython')
         os.mkdir(ipdir, 0o555)
         try:
-            open(os.path.join(ipdir, "_foo_"), 'w').close()
+            open(os.path.join(ipdir, "_foo_"), "w", encoding="utf-8").close()
         except IOError:
             pass
         else:
@@ -352,7 +352,7 b' class TestShellGlob(unittest.TestCase):'
         with cls.in_tempdir():
             # Create empty files
             for fname in cls.filenames:
-                open(os.path.join(td, fname), 'w').close()
+                open(os.path.join(td, fname), "w", encoding="utf-8").close()
 
     @classmethod
     def tearDownClass(cls):
@@ -426,9 +426,9 b' def test_ensure_dir_exists():'
         d = os.path.join(td, '∂ir')
         path.ensure_dir_exists(d) # create it
         assert os.path.isdir(d)
-        path.ensure_dir_exists(d) # no-op
-        f = os.path.join(td, 'ƒile')
-        open(f, 'w').close() # touch
+        path.ensure_dir_exists(d)  # no-op
+        f = os.path.join(td, "ƒile")
+        open(f, "w", encoding="utf-8").close()  # touch
         with pytest.raises(IOError):
             path.ensure_dir_exists(f)
 
@@ -436,7 +436,7 b' class TestLinkOrCopy(unittest.TestCase):'
     def setUp(self):
         self.tempdir = TemporaryDirectory()
         self.src = self.dst("src")
-        with open(self.src, "w") as f:
+        with open(self.src, "w", encoding="utf-8") as f:
             f.write("Hello, world!")
 
     def tearDown(self):
@@ -456,8 +456,8 b' class TestLinkOrCopy(unittest.TestCase):'
         ), "%r and %r do not reference the same indoes" % (a, b)
 
     def assert_content_equal(self, a, b):
-        with open(a) as a_f:
-            with open(b) as b_f:
+        with open(a, "rb") as a_f:
+            with open(b, "rb") as b_f:
                 assert a_f.read() == b_f.read()
 
     @skip_win32
@@ -477,7 +477,7 b' class TestLinkOrCopy(unittest.TestCase):'
     @skip_win32
     def test_target_exists(self):
         dst = self.dst("target")
-        open(dst, "w").close()
+        open(dst, "w", encoding="utf-8").close()
         path.link_or_copy(self.src, dst)
         self.assert_inode_equal(self.src, dst)
 

IPython/utils/tests/test_pycolorize.py

@@ -39,7 +39,7 b' def function(arg, *args, kwarg=True, **kwargs):'
     pass is True
     False == None
 
-    with io.open(ru'unicode'):
+    with io.open(ru'unicode', encoding='utf-8'):
         raise ValueError("\n escape \r sequence")
 
     print("wěird ünicoðe")

docs/autogen_config.py

@@ -102,7 +102,7 b' def reverse_aliases(app):'
 def write_doc(name, title, app, preamble=None):
     trait_aliases = reverse_aliases(app)
     filename = options / (name + ".rst")
-    with open(filename, "w") as f:
+    with open(filename, "w", encoding="utf-8") as f:
         f.write(title + "\n")
         f.write(("=" * len(title)) + "\n")
         f.write("\n")
@@ -117,7 +117,7 b' def write_doc(name, title, app, preamble=None):'
 
 if __name__ == '__main__':
     # Touch this file for the make target
-    Path(generated).write_text("")
+    Path(generated).write_text("", encoding="utf-8")
 
     write_doc('terminal', 'Terminal IPython options', TerminalIPythonApp())
     write_doc('kernel', 'IPython kernel options', IPKernelApp(),

docs/autogen_magics.py

@@ -63,4 +63,4 b' for name, func in sorted(magics["cell"].items(), key=sortkey):'
 
 src_path = Path(__file__).parent
 dest = src_path.joinpath("source", "interactive", "magics-generated.txt")
-dest.write_text("\n".join(output))
+dest.write_text("\n".join(output), encoding="utf-8")

docs/autogen_shortcuts.py

@@ -89,6 +89,8 b" if __name__ == '__main__':"
         (single_filter, "single_filtered"),
         (multi_filter, "multi_filtered"),
     ]:
-        with (dest / "{}.csv".format(output_filename)).open("w") as csv:
+        with (dest / "{}.csv".format(output_filename)).open(
+            "w", encoding="utf-8"
+        ) as csv:
             for (shortcut, flt), v in sorted(filters.items(), key=sort_key):
                 csv.write(":kbd:`{}`\t{}\t{}\n".format(shortcut, flt, v))

docs/requirements.txt

@@ -6,4 +6,4 b' sphinx-rtd-theme'
 docrepr
 matplotlib
 stack_data
-pytest
+pytest<7

docs/source/conf.py

@@ -28,11 +28,14 b' if ON_RTD:'
     for name in ("config", "api", "magics", "shortcuts"):
         fname = Path("autogen_{}.py".format(name))
         fpath = (Path(__file__).parent).joinpath("..", fname)
-        with open(fpath) as f:
-            exec(compile(f.read(), fname, 'exec'), {
-                '__file__': fpath,
-                '__name__': '__main__',
-            })
+        with open(fpath, encoding="utf-8") as f:
+            exec(
+                compile(f.read(), fname, "exec"),
+                {
+                    "__file__": fpath,
+                    "__name__": "__main__",
+                },
+            )
 else:
     import sphinx_rtd_theme
     html_theme = "sphinx_rtd_theme"
@@ -45,7 +48,14 b" sys.path.insert(0, os.path.abspath('../sphinxext'))"
 
 # We load the ipython release info into a dict by explicit execution
 iprelease = {}
-exec(compile(open('../../IPython/core/release.py').read(), '../../IPython/core/release.py', 'exec'),iprelease)
+exec(
+    compile(
+        open("../../IPython/core/release.py", encoding="utf-8").read(),
+        "../../IPython/core/release.py",
+        "exec",
+    ),
+    iprelease,
+)
 
 # General configuration
 # ---------------------

docs/sphinxext/apigen.py

@@ -390,9 +390,8 b' class ApiDocWriter(object):'
             if not api_str:
                 continue
             # write out to file
-            outfile = os.path.join(outdir,
-                                   m + self.rst_extension)
-            with open(outfile, 'wt') as fileobj:
+            outfile = os.path.join(outdir, m + self.rst_extension)
+            with open(outfile, "wt", encoding="utf-8") as fileobj:
                 fileobj.write(api_str)
             written_modules.append(m)
         self.written_modules = written_modules
@@ -444,7 +443,7 b' class ApiDocWriter(object):'
             relpath = outdir.replace(relative_to + os.path.sep, '')
         else:
             relpath = outdir
-        with open(path,'wt') as idx:
+        with open(path, "wt", encoding="utf-8") as idx:
             w = idx.write
             w('.. AUTO-GENERATED FILE -- DO NOT EDIT!\n\n')
             w('.. autosummary::\n'

examples/IPython Kernel/ipython-get-history.py

@@ -24,7 +24,7 b' from IPython.core.history import HistoryAccessor'
 session_number = int(sys.argv[1])
 if len(sys.argv) > 2:
     filepath = Path(sys.argv[2])
-    dest = open(filepath, "w")
+    dest = open(filepath, "w", encoding="utf-8")
     raw = not filepath.name.endswith(".py")
 else:
     dest = sys.stdout

setupbase.py

@@ -36,7 +36,7 b' repo_root = os.path.dirname(os.path.abspath(__file__))'
 
 def execfile(fname, globs, locs=None):
     locs = locs or globs
-    with open(fname) as f:
+    with open(fname, encoding="utf-8") as f:
         exec(compile(f.read(), fname, "exec"), globs, locs)
 
 # A little utility we'll need below, since glob() does NOT allow you to do
@@ -336,10 +336,13 b' def git_prebuild(pkg_dir, build_cmd=build_py):'
                 os.remove(out_pth)
             except (IOError, OSError):
                 pass
-            with open(out_pth, 'w') as out_file:
-                out_file.writelines([
-                    '# GENERATED BY setup.py\n',
-                    'commit = u"%s"\n' % repo_commit,
-                ])
+            with open(out_pth, "w", encoding="utf-8") as out_file:
+                out_file.writelines(
+                    [
+                        "# GENERATED BY setup.py\n",
+                        'commit = u"%s"\n' % repo_commit,
+                    ]
+                )
+
     return MyBuildPy
 

tools/fixup_whats_new_pr.py

@@ -22,14 +22,14 b' def main():'
         print("Adding pseudo-title to:", filepath.name)
         title = filepath.name[:-4].split("/")[-1].replace("-", " ").capitalize()
 
-        data = filepath.read_text()
+        data = filepath.read_text(encoding="utf-8")
         try:
             if data and data.splitlines()[1].startswith('='):
                 continue
         except IndexError:
             pass
 
-        with filepath.open("w") as f:
+        with filepath.open("w", encoding="utf-8") as f:
             f.write(title + "\n")
             f.write("=" * len(title) + "\n\n")
             f.write(data)

tools/toollib.py

@@ -45,4 +45,4 b' def get_ipdir():'
 
 def execfile(fname, globs, locs=None):
     locs = locs or globs
-    exec(compile(open(fname).read(), fname, "exec"), globs, locs)
+    exec(compile(open(fname, encoding="utf-8").read(), fname, "exec"), globs, locs)