fix: ensure find_dotenv work reliably on python 3.13

Not removing the check using the `__main__.__file__` for backward
compatibility and ensure we don't break any existing use-cases.

I tested and some of the environments like notebooks, VSCode notebook
and Google Colab doesn't set the `ps1` attribute of `sys`, let's revisit
and remove the extra checks if someone can prove it otherwise.

Closes #562

Thanks @burnout-projects @mpounsett

Author: theskumar

src/dotenv/main.py

@@ -286,6 +286,8 @@ def find_dotenv(
 
     def _is_interactive():
         """Decide whether this is running in a REPL or IPython notebook"""
+        if hasattr(sys, "ps1") or hasattr(sys, "ps2"):
+            return True
         try:
             main = __import__("__main__", None, None, fromlist=["__file__"])
         except ModuleNotFoundError:

tests/test_is_interactive.py

@@ -0,0 +1,292 @@
+import sys
+import pytest
+import builtins
+from unittest import mock
+from dotenv.main import find_dotenv
+
+
+class TestIsInteractive:
+    """Tests for the _is_interactive helper function within find_dotenv.
+    
+    The _is_interactive function is used by find_dotenv to determine if the code
+    is running in an interactive environment (like a REPL, IPython notebook, etc.)
+    versus a normal script execution.
+    
+    Interactive environments include:
+    - Python REPL (has sys.ps1 or sys.ps2)
+    - IPython notebooks (no __file__ in __main__)
+    - Interactive shells
+    
+    Non-interactive environments include:
+    - Normal script execution (has __file__ in __main__)
+    - Module imports
+    
+    Examples of the behavior:
+    >>> import sys
+    >>> # In a REPL:
+    >>> hasattr(sys, 'ps1')  # True
+    >>> # In a script:
+    >>> hasattr(sys, 'ps1')  # False
+    """
+    
+    def test_is_interactive_with_ps1(self, tmp_path, monkeypatch):
+        """Test that _is_interactive returns True when sys.ps1 exists."""
+        # Create a test .env file
+        dotenv_path = tmp_path / ".env"
+        dotenv_path.write_text("TEST=value")
+        
+        # Mock sys.ps1 to simulate interactive shell
+        monkeypatch.setattr(sys, "ps1", ">>> ", raising=False)
+        
+        # Change to directory without .env to force search
+        test_dir = tmp_path / "subdir"
+        test_dir.mkdir()
+        monkeypatch.chdir(test_dir)
+        
+        # When _is_interactive() returns True, find_dotenv should search from cwd
+        result = find_dotenv()
+        assert result == str(dotenv_path)
+    
+    def test_is_interactive_with_ps2(self, tmp_path, monkeypatch):
+        """Test that _is_interactive returns True when sys.ps2 exists."""
+        # Create a test .env file
+        dotenv_path = tmp_path / ".env"
+        dotenv_path.write_text("TEST=value")
+        
+        # Mock sys.ps2 to simulate multi-line interactive input
+        monkeypatch.setattr(sys, "ps2", "... ", raising=False)
+        
+        # Change to directory without .env to force search
+        test_dir = tmp_path / "subdir"
+        test_dir.mkdir()
+        monkeypatch.chdir(test_dir)
+        
+        # When _is_interactive() returns True, find_dotenv should search from cwd
+        result = find_dotenv()
+        assert result == str(dotenv_path)
+    
+    def test_is_interactive_main_module_not_found(self, tmp_path, monkeypatch):
+        """Test that _is_interactive returns False when __main__ module import fails."""
+        # Remove any ps1/ps2 attributes if they exist
+        if hasattr(sys, "ps1"):
+            monkeypatch.delattr(sys, "ps1")
+        if hasattr(sys, "ps2"):
+            monkeypatch.delattr(sys, "ps2")
+        
+        # Mock __import__ to raise ModuleNotFoundError for __main__
+        original_import = builtins.__import__
+        
+        def mock_import(name, *args, **kwargs):
+            if name == "__main__":
+                raise ModuleNotFoundError("No module named '__main__'")
+            return original_import(name, *args, **kwargs)
+        
+        monkeypatch.setattr(builtins, "__import__", mock_import)
+        
+        # Change to directory and test
+        monkeypatch.chdir(tmp_path)
+        
+        # Since _is_interactive() returns False, find_dotenv should not find anything
+        # without usecwd=True
+        result = find_dotenv()
+        assert result == ""
+    
+    def test_is_interactive_main_without_file(self, tmp_path, monkeypatch):
+        """Test that _is_interactive returns True when __main__ has no __file__ attribute."""
+        # Remove any ps1/ps2 attributes if they exist
+        if hasattr(sys, "ps1"):
+            monkeypatch.delattr(sys, "ps1")
+        if hasattr(sys, "ps2"):
+            monkeypatch.delattr(sys, "ps2")
+        
+        # Create a test .env file
+        dotenv_path = tmp_path / ".env"
+        dotenv_path.write_text("TEST=value")
+        
+        # Mock __main__ module without __file__ attribute
+        mock_main = mock.MagicMock()
+        del mock_main.__file__  # Remove __file__ attribute
+        
+        original_import = builtins.__import__
+        
+        def mock_import(name, *args, **kwargs):
+            if name == "__main__":
+                return mock_main
+            return original_import(name, *args, **kwargs)
+        
+        monkeypatch.setattr(builtins, "__import__", mock_import)
+        
+        # Change to directory without .env to force search
+        test_dir = tmp_path / "subdir"
+        test_dir.mkdir()
+        monkeypatch.chdir(test_dir)
+        
+        # When _is_interactive() returns True, find_dotenv should search from cwd
+        result = find_dotenv()
+        assert result == str(dotenv_path)
+    
+    def test_is_interactive_main_with_file(self, tmp_path, monkeypatch):
+        """Test that _is_interactive returns False when __main__ has __file__ attribute."""
+        # Remove any ps1/ps2 attributes if they exist
+        if hasattr(sys, "ps1"):
+            monkeypatch.delattr(sys, "ps1")
+        if hasattr(sys, "ps2"):
+            monkeypatch.delattr(sys, "ps2")
+        
+        # Mock __main__ module with __file__ attribute
+        mock_main = mock.MagicMock()
+        mock_main.__file__ = "/path/to/script.py"
+        
+        original_import = builtins.__import__
+        
+        def mock_import(name, *args, **kwargs):
+            if name == "__main__":
+                return mock_main
+            return original_import(name, *args, **kwargs)
+        
+        monkeypatch.setattr(builtins, "__import__", mock_import)
+        
+        # Change to directory and test
+        monkeypatch.chdir(tmp_path)
+        
+        # Since _is_interactive() returns False, find_dotenv should not find anything
+        # without usecwd=True
+        result = find_dotenv()
+        assert result == ""
+    
+    def test_is_interactive_precedence_ps1_over_main(self, tmp_path, monkeypatch):
+        """Test that ps1/ps2 attributes take precedence over __main__ module check."""
+        # Create a test .env file
+        dotenv_path = tmp_path / ".env"
+        dotenv_path.write_text("TEST=value")
+        
+        # Set ps1 attribute
+        monkeypatch.setattr(sys, "ps1", ">>> ", raising=False)
+        
+        # Mock __main__ module with __file__ attribute (which would normally return False)
+        mock_main = mock.MagicMock()
+        mock_main.__file__ = "/path/to/script.py"
+        
+        original_import = builtins.__import__
+        
+        def mock_import(name, *args, **kwargs):
+            if name == "__main__":
+                return mock_main
+            return original_import(name, *args, **kwargs)
+        
+        monkeypatch.setattr(builtins, "__import__", mock_import)
+        
+        # Change to directory without .env to force search
+        test_dir = tmp_path / "subdir"
+        test_dir.mkdir()
+        monkeypatch.chdir(test_dir)
+        
+        # ps1 should take precedence, so _is_interactive() returns True
+        result = find_dotenv()
+        assert result == str(dotenv_path)
+    
+    def test_is_interactive_ps1_and_ps2_both_exist(self, tmp_path, monkeypatch):
+        """Test that _is_interactive returns True when both ps1 and ps2 exist."""
+        # Create a test .env file
+        dotenv_path = tmp_path / ".env"
+        dotenv_path.write_text("TEST=value")
+        
+        # Set both ps1 and ps2 attributes
+        monkeypatch.setattr(sys, "ps1", ">>> ", raising=False)
+        monkeypatch.setattr(sys, "ps2", "... ", raising=False)
+        
+        # Change to directory without .env to force search
+        test_dir = tmp_path / "subdir"
+        test_dir.mkdir()
+        monkeypatch.chdir(test_dir)
+        
+        # Should return True with either attribute present
+        result = find_dotenv()
+        assert result == str(dotenv_path)
+    
+    def test_is_interactive_main_module_with_file_attribute_none(self, tmp_path, monkeypatch):
+        """Test _is_interactive when __main__ has __file__ attribute set to None."""
+        # Remove any ps1/ps2 attributes if they exist
+        if hasattr(sys, "ps1"):
+            monkeypatch.delattr(sys, "ps1")
+        if hasattr(sys, "ps2"):
+            monkeypatch.delattr(sys, "ps2")
+        
+        # Create a test .env file
+        dotenv_path = tmp_path / ".env"
+        dotenv_path.write_text("TEST=value")
+        
+        # Mock __main__ module with __file__ = None
+        mock_main = mock.MagicMock()
+        mock_main.__file__ = None
+        
+        original_import = builtins.__import__
+        
+        def mock_import(name, *args, **kwargs):
+            if name == "__main__":
+                return mock_main
+            return original_import(name, *args, **kwargs)
+        
+        monkeypatch.setattr(builtins, "__import__", mock_import)
+        
+        # Change to directory without .env to force search
+        test_dir = tmp_path / "subdir"
+        test_dir.mkdir()
+        monkeypatch.chdir(test_dir)
+        
+        # __file__ = None should still be considered non-interactive
+        result = find_dotenv()
+        assert result == ""
+    
+    def test_is_interactive_no_ps_attributes_and_normal_execution(self, tmp_path, monkeypatch):
+        """Test normal script execution scenario where _is_interactive should return False."""
+        # Remove any ps1/ps2 attributes if they exist
+        if hasattr(sys, "ps1"):
+            monkeypatch.delattr(sys, "ps1")
+        if hasattr(sys, "ps2"):
+            monkeypatch.delattr(sys, "ps2")
+        
+        # Don't mock anything - let it use the real __main__ module
+        # which should have a __file__ attribute in normal execution
+        
+        # Change to directory and test
+        monkeypatch.chdir(tmp_path)
+        
+        # In normal execution, _is_interactive() should return False
+        # so find_dotenv should not find anything without usecwd=True
+        result = find_dotenv()
+        assert result == ""
+    
+    def test_is_interactive_with_usecwd_override(self, tmp_path, monkeypatch):
+        """Test that usecwd=True overrides _is_interactive behavior."""
+        # Remove any ps1/ps2 attributes if they exist
+        if hasattr(sys, "ps1"):
+            monkeypatch.delattr(sys, "ps1")
+        if hasattr(sys, "ps2"):
+            monkeypatch.delattr(sys, "ps2")
+        
+        # Create a test .env file
+        dotenv_path = tmp_path / ".env"
+        dotenv_path.write_text("TEST=value")
+        
+        # Mock __main__ module with __file__ attribute (non-interactive)
+        mock_main = mock.MagicMock()
+        mock_main.__file__ = "/path/to/script.py"
+        
+        original_import = builtins.__import__
+        
+        def mock_import(name, *args, **kwargs):
+            if name == "__main__":
+                return mock_main
+            return original_import(name, *args, **kwargs)
+        
+        monkeypatch.setattr(builtins, "__import__", mock_import)
+        
+        # Change to directory without .env to force search
+        test_dir = tmp_path / "subdir"
+        test_dir.mkdir()
+        monkeypatch.chdir(test_dir)
+        
+        # Even though _is_interactive() returns False, usecwd=True should find the file
+        result = find_dotenv(usecwd=True)
+        assert result == str(dotenv_path)