From dd1af684f2586d2c2fdd722f9c45d3212e1e4e59 Mon Sep 17 00:00:00 2001
From: Jan Kislinger <jan.kislinger@gmail.com>
Date: Tue, 14 Mar 2023 08:32:42 +0100
Subject: [PATCH 1/9] FIx year in release in changelog (#453)

---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2f78c0d0..220d1888 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,7 +12,7 @@ project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 * Drop support for python 3.7, add python 3.12-dev (#449 by [@theskumar])
 * Handle situations where the cwd does not exist. (#446 by [@jctanner])
 
-## [0.21.1] - 2022-01-21
+## [0.21.1] - 2023-01-21
 
 **Added**
 

From 137bc3dc0b8cf3d417a1e800c4065c526e3fb96a Mon Sep 17 00:00:00 2001
From: Sam Wyma <sam.wyma@gmail.com>
Date: Mon, 17 Apr 2023 16:12:57 +0100
Subject: [PATCH 2/9] Gracefully handle code which has been imported from a
 zipfile (#456)

---
 src/dotenv/main.py        |   4 +-
 tests/test_zip_imports.py | 101 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 104 insertions(+), 1 deletion(-)
 create mode 100644 tests/test_zip_imports.py

diff --git a/src/dotenv/main.py b/src/dotenv/main.py
index f40c20ea..383b79f4 100644
--- a/src/dotenv/main.py
+++ b/src/dotenv/main.py
@@ -291,7 +291,9 @@ def _is_interactive():
         frame = sys._getframe()
         current_file = __file__
 
-        while frame.f_code.co_filename == current_file:
+        while frame.f_code.co_filename == current_file or not os.path.exists(
+            frame.f_code.co_filename
+        ):
             assert frame.f_back is not None
             frame = frame.f_back
         frame_filename = frame.f_code.co_filename
diff --git a/tests/test_zip_imports.py b/tests/test_zip_imports.py
new file mode 100644
index 00000000..46d3c02e
--- /dev/null
+++ b/tests/test_zip_imports.py
@@ -0,0 +1,101 @@
+import os
+import sys
+import sh
+import textwrap
+from typing import List
+from unittest import mock
+from zipfile import ZipFile
+
+
+def walk_to_root(path: str):
+    last_dir = None
+    current_dir = path
+    while last_dir != current_dir:
+        yield current_dir
+        (parent_dir, _) = os.path.split(current_dir)
+        last_dir, current_dir = current_dir, parent_dir
+
+
+class FileToAdd:
+    def __init__(self, content: str, path: str):
+        self.content = content
+        self.path = path
+
+
+def setup_zipfile(path, files: List[FileToAdd]):
+    zip_file_path = path / "test.zip"
+    dirs_init_py_added_to = set()
+    with ZipFile(zip_file_path, "w") as zip:
+        for f in files:
+            zip.writestr(data=f.content, zinfo_or_arcname=f.path)
+            for dir in walk_to_root(os.path.dirname(f.path)):
+                if dir not in dirs_init_py_added_to:
+                    print(os.path.join(dir, "__init__.py"))
+                    zip.writestr(
+                        data="", zinfo_or_arcname=os.path.join(dir, "__init__.py")
+                    )
+                    dirs_init_py_added_to.add(dir)
+    return zip_file_path
+
+
+@mock.patch.object(sys, "path", list(sys.path))
+def test_load_dotenv_gracefully_handles_zip_imports_when_no_env_file(tmp_path):
+    zip_file_path = setup_zipfile(
+        tmp_path,
+        [
+            FileToAdd(
+                content=textwrap.dedent(
+                    """
+            from dotenv import load_dotenv
+
+            load_dotenv()
+        """
+                ),
+                path="child1/child2/test.py",
+            ),
+        ],
+    )
+
+    # Should run without an error
+    sys.path.append(str(zip_file_path))
+    import child1.child2.test  # noqa
+
+
+def test_load_dotenv_outside_zip_file_when_called_in_zipfile(tmp_path):
+    zip_file_path = setup_zipfile(
+        tmp_path,
+        [
+            FileToAdd(
+                content=textwrap.dedent(
+                    """
+            from dotenv import load_dotenv
+
+            load_dotenv()
+        """
+                ),
+                path="child1/child2/test.py",
+            ),
+        ],
+    )
+    dotenv_path = tmp_path / ".env"
+    dotenv_path.write_bytes(b"a=b")
+    code_path = tmp_path / "code.py"
+    code_path.write_text(
+        textwrap.dedent(
+            f"""
+        import os
+        import sys
+
+        sys.path.append("{zip_file_path}")
+
+        import child1.child2.test
+
+        print(os.environ['a'])
+    """
+        )
+    )
+    os.chdir(str(tmp_path))
+
+    result = sh.Command(sys.executable)(code_path)
+
+    assert result == "b\n"

From be96be259c7eaf687360367de53e5e099aea48df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Miroslav=20=C5=A0ediv=C3=BD?=
 <6774676+eumiro@users.noreply.github.com>
Date: Sat, 24 Jun 2023 10:02:12 +0200
Subject: [PATCH 3/9] Use pathlib.Path in tests (#466)

---
 tests/conftest.py     |   8 +-
 tests/test_cli.py     |  93 +++++++++-----------
 tests/test_ipython.py |   6 +-
 tests/test_main.py    | 196 ++++++++++++++++++------------------------
 4 files changed, 134 insertions(+), 169 deletions(-)

diff --git a/tests/conftest.py b/tests/conftest.py
index 24a82528..69193de0 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -10,7 +10,7 @@ def cli():
 
 
 @pytest.fixture
-def dotenv_file(tmp_path):
-    file_ = tmp_path / '.env'
-    file_.write_bytes(b'')
-    yield str(file_)
+def dotenv_path(tmp_path):
+    path = tmp_path / '.env'
+    path.write_bytes(b'')
+    yield path
diff --git a/tests/test_cli.py b/tests/test_cli.py
index 8afbe59d..fc309b48 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -1,8 +1,10 @@
 import os
-
-import pytest
 import sh
+from pathlib import Path
 from typing import Optional
+
+import pytest
+
 import dotenv
 from dotenv.cli import cli as dotenv_cli
 from dotenv.version import __version__
@@ -23,11 +25,10 @@
         ("export", "x='a b c'", '''export x='a b c'\n'''),
     )
 )
-def test_list(cli, dotenv_file, format: Optional[str], content: str, expected: str):
-    with open(dotenv_file, "w") as f:
-        f.write(content + '\n')
+def test_list(cli, dotenv_path, format: Optional[str], content: str, expected: str):
+    dotenv_path.write_text(content + '\n')
 
-    args = ['--file', dotenv_file, 'list']
+    args = ['--file', dotenv_path, 'list']
     if format is not None:
         args.extend(['--format', format])
 
@@ -56,17 +57,16 @@ def test_list_no_file(cli):
     assert (result.exit_code, result.output) == (1, "")
 
 
-def test_get_existing_value(cli, dotenv_file):
-    with open(dotenv_file, "w") as f:
-        f.write("a=b")
+def test_get_existing_value(cli, dotenv_path):
+    dotenv_path.write_text("a=b")
 
-    result = cli.invoke(dotenv_cli, ['--file', dotenv_file, 'get', 'a'])
+    result = cli.invoke(dotenv_cli, ['--file', dotenv_path, 'get', 'a'])
 
     assert (result.exit_code, result.output) == (0, "b\n")
 
 
-def test_get_non_existent_value(cli, dotenv_file):
-    result = cli.invoke(dotenv_cli, ['--file', dotenv_file, 'get', 'a'])
+def test_get_non_existent_value(cli, dotenv_path):
+    result = cli.invoke(dotenv_cli, ['--file', dotenv_path, 'get', 'a'])
 
     assert (result.exit_code, result.output) == (1, "")
 
@@ -85,21 +85,20 @@ def test_get_not_a_file(cli):
     assert "Error opening env file" in result.output
 
 
-def test_unset_existing_value(cli, dotenv_file):
-    with open(dotenv_file, "w") as f:
-        f.write("a=b")
+def test_unset_existing_value(cli, dotenv_path):
+    dotenv_path.write_text("a=b")
 
-    result = cli.invoke(dotenv_cli, ['--file', dotenv_file, 'unset', 'a'])
+    result = cli.invoke(dotenv_cli, ['--file', dotenv_path, 'unset', 'a'])
 
     assert (result.exit_code, result.output) == (0, "Successfully removed a\n")
-    assert open(dotenv_file, "r").read() == ""
+    assert dotenv_path.read_text() == ""
 
 
-def test_unset_non_existent_value(cli, dotenv_file):
-    result = cli.invoke(dotenv_cli, ['--file', dotenv_file, 'unset', 'a'])
+def test_unset_non_existent_value(cli, dotenv_path):
+    result = cli.invoke(dotenv_cli, ['--file', dotenv_path, 'unset', 'a'])
 
     assert (result.exit_code, result.output) == (1, "")
-    assert open(dotenv_file, "r").read() == ""
+    assert dotenv_path.read_text() == ""
 
 
 @pytest.mark.parametrize(
@@ -112,31 +111,31 @@ def test_unset_non_existent_value(cli, dotenv_file):
         ("auto", "a", "$", "a='$'\n"),
     )
 )
-def test_set_quote_options(cli, dotenv_file, quote_mode, variable, value, expected):
+def test_set_quote_options(cli, dotenv_path, quote_mode, variable, value, expected):
     result = cli.invoke(
         dotenv_cli,
-        ["--file", dotenv_file, "--export", "false", "--quote", quote_mode, "set", variable, value]
+        ["--file", dotenv_path, "--export", "false", "--quote", quote_mode, "set", variable, value]
     )
 
     assert (result.exit_code, result.output) == (0, "{}={}\n".format(variable, value))
-    assert open(dotenv_file, "r").read() == expected
+    assert dotenv_path.read_text() == expected
 
 
 @pytest.mark.parametrize(
-    "dotenv_file,export_mode,variable,value,expected",
+    "dotenv_path,export_mode,variable,value,expected",
     (
-        (".nx_file", "true", "a", "x", "export a='x'\n"),
-        (".nx_file", "false", "a", "x", "a='x'\n"),
+        (Path(".nx_file"), "true", "a", "x", "export a='x'\n"),
+        (Path(".nx_file"), "false", "a", "x", "a='x'\n"),
     )
 )
-def test_set_export(cli, dotenv_file, export_mode, variable, value, expected):
+def test_set_export(cli, dotenv_path, export_mode, variable, value, expected):
     result = cli.invoke(
         dotenv_cli,
-        ["--file", dotenv_file, "--quote", "always", "--export", export_mode, "set", variable, value]
+        ["--file", dotenv_path, "--quote", "always", "--export", export_mode, "set", variable, value]
     )
 
     assert (result.exit_code, result.output) == (0, "{}={}\n".format(variable, value))
-    assert open(dotenv_file, "r").read() == expected
+    assert dotenv_path.read_text() == expected
 
 
 def test_set_non_existent_file(cli):
@@ -153,9 +152,8 @@ def test_set_no_file(cli):
 
 
 def test_get_default_path(tmp_path):
-    with sh.pushd(str(tmp_path)):
-        with open(str(tmp_path / ".env"), "w") as f:
-            f.write("a=b")
+    with sh.pushd(tmp_path):
+        (tmp_path / ".env").write_text("a=b")
 
         result = sh.dotenv("get", "a")
 
@@ -163,10 +161,8 @@ def test_get_default_path(tmp_path):
 
 
 def test_run(tmp_path):
-    with sh.pushd(str(tmp_path)):
-        dotenv_file = str(tmp_path / ".env")
-        with open(dotenv_file, "w") as f:
-            f.write("a=b")
+    with sh.pushd(tmp_path):
+        (tmp_path / ".env").write_text("a=b")
 
         result = sh.dotenv("run", "printenv", "a")
 
@@ -174,10 +170,8 @@ def test_run(tmp_path):
 
 
 def test_run_with_existing_variable(tmp_path):
-    with sh.pushd(str(tmp_path)):
-        dotenv_file = str(tmp_path / ".env")
-        with open(dotenv_file, "w") as f:
-            f.write("a=b")
+    with sh.pushd(tmp_path):
+        (tmp_path / ".env").write_text("a=b")
         env = dict(os.environ)
         env.update({"LANG": "en_US.UTF-8", "a": "c"})
 
@@ -187,10 +181,8 @@ def test_run_with_existing_variable(tmp_path):
 
 
 def test_run_with_existing_variable_not_overridden(tmp_path):
-    with sh.pushd(str(tmp_path)):
-        dotenv_file = str(tmp_path / ".env")
-        with open(dotenv_file, "w") as f:
-            f.write("a=b")
+    with sh.pushd(tmp_path):
+        (tmp_path / ".env").write_text("a=b")
         env = dict(os.environ)
         env.update({"LANG": "en_US.UTF-8", "a": "c"})
 
@@ -200,21 +192,18 @@ def test_run_with_existing_variable_not_overridden(tmp_path):
 
 
 def test_run_with_none_value(tmp_path):
-    with sh.pushd(str(tmp_path)):
-        dotenv_file = str(tmp_path / ".env")
-        with open(dotenv_file, "w") as f:
-            f.write("a=b\nc")
+    with sh.pushd(tmp_path):
+        (tmp_path / ".env").write_text("a=b\nc")
 
         result = sh.dotenv("run", "printenv", "a")
 
         assert result == "b\n"
 
 
-def test_run_with_other_env(dotenv_file):
-    with open(dotenv_file, "w") as f:
-        f.write("a=b")
+def test_run_with_other_env(dotenv_path):
+    dotenv_path.write_text("a=b")
 
-    result = sh.dotenv("--file", dotenv_file, "run", "printenv", "a")
+    result = sh.dotenv("--file", dotenv_path, "run", "printenv", "a")
 
     assert result == "b\n"
 
diff --git a/tests/test_ipython.py b/tests/test_ipython.py
index f988bd9c..960479ba 100644
--- a/tests/test_ipython.py
+++ b/tests/test_ipython.py
@@ -13,7 +13,7 @@ def test_ipython_existing_variable_no_override(tmp_path):
 
     dotenv_file = tmp_path / ".env"
     dotenv_file.write_text("a=b\n")
-    os.chdir(str(tmp_path))
+    os.chdir(tmp_path)
     os.environ["a"] = "c"
 
     ipshell = InteractiveShellEmbed()
@@ -29,7 +29,7 @@ def test_ipython_existing_variable_override(tmp_path):
 
     dotenv_file = tmp_path / ".env"
     dotenv_file.write_text("a=b\n")
-    os.chdir(str(tmp_path))
+    os.chdir(tmp_path)
     os.environ["a"] = "c"
 
     ipshell = InteractiveShellEmbed()
@@ -45,7 +45,7 @@ def test_ipython_new_variable(tmp_path):
 
     dotenv_file = tmp_path / ".env"
     dotenv_file.write_text("a=b\n")
-    os.chdir(str(tmp_path))
+    os.chdir(tmp_path)
 
     ipshell = InteractiveShellEmbed()
     ipshell.run_line_magic("load_ext", "dotenv")
diff --git a/tests/test_main.py b/tests/test_main.py
index 9c895851..fd5e3903 100644
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -12,14 +12,14 @@
 
 
 def test_set_key_no_file(tmp_path):
-    nx_file = str(tmp_path / "nx")
+    nx_path = tmp_path / "nx"
     logger = logging.getLogger("dotenv.main")
 
     with mock.patch.object(logger, "warning"):
-        result = dotenv.set_key(nx_file, "foo", "bar")
+        result = dotenv.set_key(nx_path, "foo", "bar")
 
     assert result == (True, "foo", "bar")
-    assert os.path.exists(nx_file)
+    assert nx_path.exists()
 
 
 @pytest.mark.parametrize(
@@ -40,162 +40,151 @@ def test_set_key_no_file(tmp_path):
         ("a=b", "c", "d", (True, "c", "d"), "a=b\nc='d'\n"),
     ],
 )
-def test_set_key(dotenv_file, before, key, value, expected, after):
+def test_set_key(dotenv_path, before, key, value, expected, after):
     logger = logging.getLogger("dotenv.main")
-    with open(dotenv_file, "w") as f:
-        f.write(before)
+    dotenv_path.write_text(before)
 
     with mock.patch.object(logger, "warning") as mock_warning:
-        result = dotenv.set_key(dotenv_file, key, value)
+        result = dotenv.set_key(dotenv_path, key, value)
 
     assert result == expected
-    assert open(dotenv_file, "r").read() == after
+    assert dotenv_path.read_text() == after
     mock_warning.assert_not_called()
 
 
-def test_set_key_encoding(dotenv_file):
+def test_set_key_encoding(dotenv_path):
     encoding = "latin-1"
 
-    result = dotenv.set_key(dotenv_file, "a", "é", encoding=encoding)
+    result = dotenv.set_key(dotenv_path, "a", "é", encoding=encoding)
 
     assert result == (True, "a", "é")
-    assert open(dotenv_file, "r", encoding=encoding).read() == "a='é'\n"
+    assert dotenv_path.read_text(encoding=encoding) == "a='é'\n"
 
 
-def test_set_key_permission_error(dotenv_file):
-    os.chmod(dotenv_file, 0o000)
+def test_set_key_permission_error(dotenv_path):
+    dotenv_path.chmod(0o000)
 
     with pytest.raises(Exception):
-        dotenv.set_key(dotenv_file, "a", "b")
+        dotenv.set_key(dotenv_path, "a", "b")
 
-    os.chmod(dotenv_file, 0o600)
-    with open(dotenv_file, "r") as fp:
-        assert fp.read() == ""
+    dotenv_path.chmod(0o600)
+    assert dotenv_path.read_text() == ""
 
 
 def test_get_key_no_file(tmp_path):
-    nx_file = str(tmp_path / "nx")
+    nx_path = tmp_path / "nx"
     logger = logging.getLogger("dotenv.main")
 
     with mock.patch.object(logger, "info") as mock_info, \
             mock.patch.object(logger, "warning") as mock_warning:
-        result = dotenv.get_key(nx_file, "foo")
+        result = dotenv.get_key(nx_path, "foo")
 
     assert result is None
     mock_info.assert_has_calls(
         calls=[
-            mock.call("Python-dotenv could not find configuration file %s.", nx_file)
+            mock.call("Python-dotenv could not find configuration file %s.", nx_path)
         ],
     )
     mock_warning.assert_has_calls(
         calls=[
-            mock.call("Key %s not found in %s.", "foo", nx_file)
+            mock.call("Key %s not found in %s.", "foo", nx_path)
         ],
     )
 
 
-def test_get_key_not_found(dotenv_file):
+def test_get_key_not_found(dotenv_path):
     logger = logging.getLogger("dotenv.main")
 
     with mock.patch.object(logger, "warning") as mock_warning:
-        result = dotenv.get_key(dotenv_file, "foo")
+        result = dotenv.get_key(dotenv_path, "foo")
 
     assert result is None
-    mock_warning.assert_called_once_with("Key %s not found in %s.", "foo", dotenv_file)
+    mock_warning.assert_called_once_with("Key %s not found in %s.", "foo", dotenv_path)
 
 
-def test_get_key_ok(dotenv_file):
+def test_get_key_ok(dotenv_path):
     logger = logging.getLogger("dotenv.main")
-    with open(dotenv_file, "w") as f:
-        f.write("foo=bar")
+    dotenv_path.write_text("foo=bar")
 
     with mock.patch.object(logger, "warning") as mock_warning:
-        result = dotenv.get_key(dotenv_file, "foo")
+        result = dotenv.get_key(dotenv_path, "foo")
 
     assert result == "bar"
     mock_warning.assert_not_called()
 
 
-def test_get_key_encoding(dotenv_file):
+def test_get_key_encoding(dotenv_path):
     encoding = "latin-1"
-    with open(dotenv_file, "w", encoding=encoding) as f:
-        f.write("é=è")
+    dotenv_path.write_text("é=è", encoding=encoding)
 
-    result = dotenv.get_key(dotenv_file, "é", encoding=encoding)
+    result = dotenv.get_key(dotenv_path, "é", encoding=encoding)
 
     assert result == "è"
 
 
-def test_get_key_none(dotenv_file):
+def test_get_key_none(dotenv_path):
     logger = logging.getLogger("dotenv.main")
-    with open(dotenv_file, "w") as f:
-        f.write("foo")
+    dotenv_path.write_text("foo")
 
     with mock.patch.object(logger, "warning") as mock_warning:
-        result = dotenv.get_key(dotenv_file, "foo")
+        result = dotenv.get_key(dotenv_path, "foo")
 
     assert result is None
     mock_warning.assert_not_called()
 
 
-def test_unset_with_value(dotenv_file):
+def test_unset_with_value(dotenv_path):
     logger = logging.getLogger("dotenv.main")
-    with open(dotenv_file, "w") as f:
-        f.write("a=b\nc=d")
+    dotenv_path.write_text("a=b\nc=d")
 
     with mock.patch.object(logger, "warning") as mock_warning:
-        result = dotenv.unset_key(dotenv_file, "a")
+        result = dotenv.unset_key(dotenv_path, "a")
 
     assert result == (True, "a")
-    with open(dotenv_file, "r") as f:
-        assert f.read() == "c=d"
+    assert dotenv_path.read_text() == "c=d"
     mock_warning.assert_not_called()
 
 
-def test_unset_no_value(dotenv_file):
+def test_unset_no_value(dotenv_path):
     logger = logging.getLogger("dotenv.main")
-    with open(dotenv_file, "w") as f:
-        f.write("foo")
+    dotenv_path.write_text("foo")
 
     with mock.patch.object(logger, "warning") as mock_warning:
-        result = dotenv.unset_key(dotenv_file, "foo")
+        result = dotenv.unset_key(dotenv_path, "foo")
 
     assert result == (True, "foo")
-    with open(dotenv_file, "r") as f:
-        assert f.read() == ""
+    assert dotenv_path.read_text() == ""
     mock_warning.assert_not_called()
 
 
-def test_unset_encoding(dotenv_file):
+def test_unset_encoding(dotenv_path):
     encoding = "latin-1"
-    with open(dotenv_file, "w", encoding=encoding) as f:
-        f.write("é=x")
+    dotenv_path.write_text("é=x", encoding=encoding)
 
-    result = dotenv.unset_key(dotenv_file, "é", encoding=encoding)
+    result = dotenv.unset_key(dotenv_path, "é", encoding=encoding)
 
     assert result == (True, "é")
-    with open(dotenv_file, "r", encoding=encoding) as f:
-        assert f.read() == ""
+    assert dotenv_path.read_text(encoding=encoding) == ""
 
 
-def test_set_key_unauthorized_file(dotenv_file):
-    os.chmod(dotenv_file, 0o000)
+def test_set_key_unauthorized_file(dotenv_path):
+    dotenv_path.chmod(0o000)
 
     with pytest.raises(PermissionError):
-        dotenv.set_key(dotenv_file, "a", "x")
+        dotenv.set_key(dotenv_path, "a", "x")
 
 
 def test_unset_non_existent_file(tmp_path):
-    nx_file = str(tmp_path / "nx")
+    nx_path = tmp_path / "nx"
     logger = logging.getLogger("dotenv.main")
 
     with mock.patch.object(logger, "warning") as mock_warning:
-        result = dotenv.unset_key(nx_file, "foo")
+        result = dotenv.unset_key(nx_path, "foo")
 
     assert result == (None, "foo")
     mock_warning.assert_called_once_with(
         "Can't delete from %s - it doesn't exist.",
-        nx_file,
+        nx_path,
     )
 
 
@@ -213,27 +202,22 @@ def prepare_file_hierarchy(path):
     Then try to automatically `find_dotenv` starting in `child4`
     """
 
-    curr_dir = path
-    dirs = []
-    for f in ['child1', 'child2', 'child3', 'child4']:
-        curr_dir /= f
-        dirs.append(curr_dir)
-        curr_dir.mkdir()
-
-    return (dirs[0], dirs[-1])
+    leaf = path / "child1" / "child2" / "child3" / "child4"
+    leaf.mkdir(parents=True, exist_ok=True)
+    return leaf
 
 
 def test_find_dotenv_no_file_raise(tmp_path):
-    (root, leaf) = prepare_file_hierarchy(tmp_path)
-    os.chdir(str(leaf))
+    leaf = prepare_file_hierarchy(tmp_path)
+    os.chdir(leaf)
 
     with pytest.raises(IOError):
         dotenv.find_dotenv(raise_error_if_not_found=True, usecwd=True)
 
 
 def test_find_dotenv_no_file_no_raise(tmp_path):
-    (root, leaf) = prepare_file_hierarchy(tmp_path)
-    os.chdir(str(leaf))
+    leaf = prepare_file_hierarchy(tmp_path)
+    os.chdir(leaf)
 
     result = dotenv.find_dotenv(usecwd=True)
 
@@ -241,22 +225,21 @@ def test_find_dotenv_no_file_no_raise(tmp_path):
 
 
 def test_find_dotenv_found(tmp_path):
-    (root, leaf) = prepare_file_hierarchy(tmp_path)
-    os.chdir(str(leaf))
-    dotenv_file = root / ".env"
-    dotenv_file.write_bytes(b"TEST=test\n")
+    leaf = prepare_file_hierarchy(tmp_path)
+    os.chdir(leaf)
+    dotenv_path = tmp_path / ".env"
+    dotenv_path.write_bytes(b"TEST=test\n")
 
     result = dotenv.find_dotenv(usecwd=True)
 
-    assert result == str(dotenv_file)
+    assert result == str(dotenv_path)
 
 
 @mock.patch.dict(os.environ, {}, clear=True)
-def test_load_dotenv_existing_file(dotenv_file):
-    with open(dotenv_file, "w") as f:
-        f.write("a=b")
+def test_load_dotenv_existing_file(dotenv_path):
+    dotenv_path.write_text("a=b")
 
-    result = dotenv.load_dotenv(dotenv_file)
+    result = dotenv.load_dotenv(dotenv_path)
 
     assert result is True
     assert os.environ == {"a": "b"}
@@ -273,44 +256,40 @@ def test_load_dotenv_no_file_verbose():
 
 
 @mock.patch.dict(os.environ, {"a": "c"}, clear=True)
-def test_load_dotenv_existing_variable_no_override(dotenv_file):
-    with open(dotenv_file, "w") as f:
-        f.write("a=b")
+def test_load_dotenv_existing_variable_no_override(dotenv_path):
+    dotenv_path.write_text("a=b")
 
-    result = dotenv.load_dotenv(dotenv_file, override=False)
+    result = dotenv.load_dotenv(dotenv_path, override=False)
 
     assert result is True
     assert os.environ == {"a": "c"}
 
 
 @mock.patch.dict(os.environ, {"a": "c"}, clear=True)
-def test_load_dotenv_existing_variable_override(dotenv_file):
-    with open(dotenv_file, "w") as f:
-        f.write("a=b")
+def test_load_dotenv_existing_variable_override(dotenv_path):
+    dotenv_path.write_text("a=b")
 
-    result = dotenv.load_dotenv(dotenv_file, override=True)
+    result = dotenv.load_dotenv(dotenv_path, override=True)
 
     assert result is True
     assert os.environ == {"a": "b"}
 
 
 @mock.patch.dict(os.environ, {"a": "c"}, clear=True)
-def test_load_dotenv_redefine_var_used_in_file_no_override(dotenv_file):
-    with open(dotenv_file, "w") as f:
-        f.write('a=b\nd="${a}"')
+def test_load_dotenv_redefine_var_used_in_file_no_override(dotenv_path):
+    dotenv_path.write_text('a=b\nd="${a}"')
 
-    result = dotenv.load_dotenv(dotenv_file)
+    result = dotenv.load_dotenv(dotenv_path)
 
     assert result is True
     assert os.environ == {"a": "c", "d": "c"}
 
 
 @mock.patch.dict(os.environ, {"a": "c"}, clear=True)
-def test_load_dotenv_redefine_var_used_in_file_with_override(dotenv_file):
-    with open(dotenv_file, "w") as f:
-        f.write('a=b\nd="${a}"')
+def test_load_dotenv_redefine_var_used_in_file_with_override(dotenv_path):
+    dotenv_path.write_text('a=b\nd="${a}"')
 
-    result = dotenv.load_dotenv(dotenv_file, override=True)
+    result = dotenv.load_dotenv(dotenv_path, override=True)
 
     assert result is True
     assert os.environ == {"a": "b", "d": "b"}
@@ -327,11 +306,10 @@ def test_load_dotenv_string_io_utf_8():
 
 
 @mock.patch.dict(os.environ, {}, clear=True)
-def test_load_dotenv_file_stream(dotenv_file):
-    with open(dotenv_file, "w") as f:
-        f.write("a=b")
+def test_load_dotenv_file_stream(dotenv_path):
+    dotenv_path.write_text("a=b")
 
-    with open(dotenv_file, "r") as f:
+    with dotenv_path.open() as f:
         result = dotenv.load_dotenv(stream=f)
 
     assert result is True
@@ -349,18 +327,17 @@ def test_load_dotenv_in_current_dir(tmp_path):
         dotenv.load_dotenv(verbose=True)
         print(os.environ['a'])
     """))
-    os.chdir(str(tmp_path))
+    os.chdir(tmp_path)
 
     result = sh.Command(sys.executable)(code_path)
 
     assert result == 'b\n'
 
 
-def test_dotenv_values_file(dotenv_file):
-    with open(dotenv_file, "w") as f:
-        f.write("a=b")
+def test_dotenv_values_file(dotenv_path):
+    dotenv_path.write_text("a=b")
 
-    result = dotenv.dotenv_values(dotenv_file)
+    result = dotenv.dotenv_values(dotenv_path)
 
     assert result == {"a": "b"}
 
@@ -415,11 +392,10 @@ def test_dotenv_values_string_io(env, string, interpolate, expected):
         assert result == expected
 
 
-def test_dotenv_values_file_stream(dotenv_file):
-    with open(dotenv_file, "w") as f:
-        f.write("a=b")
+def test_dotenv_values_file_stream(dotenv_path):
+    dotenv_path.write_text("a=b")
 
-    with open(dotenv_file, "r") as f:
+    with dotenv_path.open() as f:
         result = dotenv.dotenv_values(stream=f)
 
     assert result == {"a": "b"}

From 3ffcef60d10813b72ecf85d5941d51b0207cd40e Mon Sep 17 00:00:00 2001
From: Nicolas Appriou <nicolas.appriou@gmail.com>
Date: Fri, 7 Jul 2023 19:27:15 +0200
Subject: [PATCH 4/9] Use https in README links (#474)

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 89fc6434..ddc8ba87 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@
 
 Python-dotenv reads key-value pairs from a `.env` file and can set them as environment
 variables. It helps in the development of applications following the
-[12-factor](http://12factor.net/) principles.
+[12-factor](https://12factor.net/) principles.
 
 - [Getting Started](#getting-started)
 - [Other Use Cases](#other-use-cases)
@@ -243,5 +243,5 @@ people](https://github.com/theskumar/python-dotenv/graphs/contributors).
 [build_status_badge]: https://github.com/theskumar/python-dotenv/actions/workflows/test.yml/badge.svg
 [build_status_link]: https://github.com/theskumar/python-dotenv/actions/workflows/test.yml
 [pypi_badge]: https://badge.fury.io/py/python-dotenv.svg
-[pypi_link]: http://badge.fury.io/py/python-dotenv
+[pypi_link]: https://badge.fury.io/py/python-dotenv
 [python_streams]: https://docs.python.org/3/library/io.html

From 0b94ac0822241eb526828cf506048fb0525d5c38 Mon Sep 17 00:00:00 2001
From: Freddy Boulton <alfonsoboulton@gmail.com>
Date: Mon, 22 Jan 2024 21:45:11 -0800
Subject: [PATCH 5/9] Allow modules using load_dotenv to be reloaded when
 launched in a separate thread (#497)

Update `is_interactive` code
---
 src/dotenv/main.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/dotenv/main.py b/src/dotenv/main.py
index 383b79f4..20c7782e 100644
--- a/src/dotenv/main.py
+++ b/src/dotenv/main.py
@@ -280,7 +280,10 @@ def find_dotenv(
 
     def _is_interactive():
         """ Decide whether this is running in a REPL or IPython notebook """
-        main = __import__('__main__', None, None, fromlist=['__file__'])
+        try:
+            main = __import__('__main__', None, None, fromlist=['__file__'])
+        except ModuleNotFoundError:
+            return False
         return not hasattr(main, '__file__')
 
     if usecwd or _is_interactive() or getattr(sys, 'frozen', False):

From 6ff139147559eff4d124c038ec5a4b60ffcf3033 Mon Sep 17 00:00:00 2001
From: Qwerty-133 <74311372+Qwerty-133@users.noreply.github.com>
Date: Tue, 23 Jan 2024 11:21:15 +0530
Subject: [PATCH 6/9] Fix temporary file is deleted before closing, in the
 rewrite function (#468)

Currently, if an error is raised while using files from the rewrite function, then the temporary file is deleted before closing it.

This is okay on unix, but unlinking open files causes an error on Windows.
---
 src/dotenv/main.py | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/src/dotenv/main.py b/src/dotenv/main.py
index 20c7782e..7bc54285 100644
--- a/src/dotenv/main.py
+++ b/src/dotenv/main.py
@@ -1,6 +1,7 @@
 import io
 import logging
 import os
+import pathlib
 import shutil
 import sys
 import tempfile
@@ -131,17 +132,21 @@ def rewrite(
     path: StrPath,
     encoding: Optional[str],
 ) -> Iterator[Tuple[IO[str], IO[str]]]:
-    if not os.path.isfile(path):
-        with open(path, mode="w", encoding=encoding) as source:
-            source.write("")
+    pathlib.Path(path).touch()
+
     with tempfile.NamedTemporaryFile(mode="w", encoding=encoding, delete=False) as dest:
+        error = None
         try:
             with open(path, encoding=encoding) as source:
                 yield (source, dest)
-        except BaseException:
-            os.unlink(dest.name)
-            raise
-    shutil.move(dest.name, path)
+        except BaseException as err:
+            error = err
+
+    if error is None:
+        shutil.move(dest.name, path)
+    else:
+        os.unlink(dest.name)
+        raise error from None
 
 
 def set_key(

From b1eebbaaab2cf3e1c48fa5c7ad88cfb00e4b5e54 Mon Sep 17 00:00:00 2001
From: Saurabh Kumar <theskumar@users.noreply.github.com>
Date: Tue, 23 Jan 2024 11:34:15 +0530
Subject: [PATCH 7/9] Add python 3.12 and pypy3.10 to test runner

---
 .github/workflows/test.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 49e1399f..68503d45 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -11,10 +11,10 @@ jobs:
       matrix:
         os:
           - ubuntu-latest
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12-dev", pypy3.9]
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", pypy3.9, pypy3.10]
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
 
     - name: Set up Python ${{ matrix.python-version }}
       uses: actions/setup-python@v4

From 42dc08664bc7cef185a139137a39126a030f272c Mon Sep 17 00:00:00 2001
From: Saurabh Kumar <theskumar@users.noreply.github.com>
Date: Tue, 23 Jan 2024 11:49:30 +0530
Subject: [PATCH 8/9] Update changelog for 1.0.1

---
 CHANGELOG.md | 29 +++++++++++++++++++++++++++--
 1 file changed, 27 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 220d1888..f63a1f93 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,7 +5,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this
 project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [1.0.0]
+## [1.0.1] - 2024-01-23
+
+**Fixed**
+
+* Gracefully handle code which has been imported from a zipfile ([#456] by [@samwyma])
+* Allow modules using load_dotenv to be reloaded when launched in a separate thread ([#497] by [@freddyaboulton])
+* Fix file not closed after deletion, handle error in the rewrite function ([#469] by [@Qwerty-133])
+
+**Misc**
+* Use pathlib.Path in tests ([#466] by [@eumiro])
+* Fix year in release date in changelog.md ([#454] by [@jankislinger])
+* Use https in README links ([#474] by [@Nicals])
+
+## [1.0.0] - 2023-02-24
 
 **Fixed**
 
@@ -328,6 +341,11 @@ project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 [#176]: https://github.com/theskumar/python-dotenv/issues/176
 [#183]: https://github.com/theskumar/python-dotenv/issues/183
 [#359]: https://github.com/theskumar/python-dotenv/issues/359
+[#469]: https://github.com/theskumar/python-dotenv/issues/469
+[#456]: https://github.com/theskumar/python-dotenv/issues/456
+[#466]: https://github.com/theskumar/python-dotenv/issues/466
+[#454]: https://github.com/theskumar/python-dotenv/issues/454
+[#474]: https://github.com/theskumar/python-dotenv/issues/474
 
 [@alanjds]: https://github.com/alanjds
 [@altendky]: https://github.com/altendky
@@ -341,21 +359,27 @@ project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 [@eggplants]: https://github.com/@eggplants
 [@ekohl]: https://github.com/ekohl
 [@elbehery95]: https://github.com/elbehery95
+[@eumiro]: https://github.com/eumiro
 [@Flimm]: https://github.com/Flimm
+[@freddyaboulton]: https://github.com/freddyaboulton
 [@gergelyk]: https://github.com/gergelyk
 [@gongqingkui]: https://github.com/gongqingkui
 [@greyli]: https://github.com/greyli
 [@harveer07]: https://github.com/@harveer07
 [@jadutter]: https://github.com/jadutter
+[@jankislinger]: https://github.com/jankislinger
 [@jctanner]: https://github.com/jctanner
 [@larsks]: https://github.com/@larsks
 [@lsmith77]: https://github.com/lsmith77
 [@mgorny]: https://github.com/mgorny
 [@naorlivne]: https://github.com/@naorlivne
+[@Nicals]: https://github.com/Nicals
 [@Nougat-Waffle]: https://github.com/Nougat-Waffle
 [@qnighy]: https://github.com/qnighy
+[@Qwerty-133]: https://github.com/Qwerty-133
 [@rabinadk1]: https://github.com/@rabinadk1
 [@sammck]: https://github.com/@sammck
+[@samwyma]: https://github.com/samwyma
 [@snobu]: https://github.com/snobu
 [@techalchemy]: https://github.com/techalchemy
 [@theGOTOguy]: https://github.com/theGOTOguy
@@ -367,7 +391,8 @@ project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 [@zueve]: https://github.com/zueve
 
 
-[Unreleased]: https://github.com/theskumar/python-dotenv/compare/v1.0.0...HEAD
+[Unreleased]: https://github.com/theskumar/python-dotenv/compare/v1.0.1...HEAD
+[1.0.1]: https://github.com/theskumar/python-dotenv/compare/v1.0.0...v1.0.1
 [1.0.0]: https://github.com/theskumar/python-dotenv/compare/v0.21.0...v1.0.0
 [0.21.1]: https://github.com/theskumar/python-dotenv/compare/v0.21.0...v0.21.1
 [0.21.0]: https://github.com/theskumar/python-dotenv/compare/v0.20.0...v0.21.0

From d6c0b9638349a7dd605d60ee555ff60421c1a594 Mon Sep 17 00:00:00 2001
From: Saurabh Kumar <theskumar@users.noreply.github.com>
Date: Tue, 23 Jan 2024 12:00:33 +0530
Subject: [PATCH 9/9] Bumpversion 1.0.0 -> 1.0.1

---
 src/dotenv/version.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dotenv/version.py b/src/dotenv/version.py
index 5becc17c..5c4105cd 100644
--- a/src/dotenv/version.py
+++ b/src/dotenv/version.py
@@ -1 +1 @@
-__version__ = "1.0.0"
+__version__ = "1.0.1"