lint: allow ASYNC240 (#6703)

## 📝 Summary

Some basic tidy with the new ruff rule

Author: dmadisetti

marimo/_lint/linter.py

@@ -17,6 +17,7 @@
 from marimo._lint.rule_engine import EarlyStoppingConfig, RuleEngine
 from marimo._loggers import capture_output
 from marimo._schemas.serialization import NotebookSerialization
+from marimo._utils import async_path
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Callable, Iterator
@@ -114,7 +115,7 @@ async def _process_single_file(self, file: Path) -> FileStatus:
         file_path = str(file)
         file_status = FileStatus(file=file_path)
         # Check if file exists first
-        if not file.exists():
+        if not await async_path.exists(file):
             self.errored = True
             file_status.failed = True
             file_status.message = f"File not found: {file_path}"

marimo/_server/export/exporter.py

@@ -53,6 +53,7 @@
 )
 from marimo._server.tokens import SkewProtectionToken
 from marimo._types.ids import CellId_t
+from marimo._utils import async_path
 from marimo._utils.code import hash_code
 from marimo._utils.data_uri import build_data_url
 from marimo._utils.marimo_path import MarimoPath
@@ -529,10 +530,10 @@ async def _ensure_export_dir_async(self, directory: Path) -> None:
         if export_dir in self._created_dirs:
             return
 
-        if not directory.exists():
+        if not await async_path.exists(directory):
             raise FileNotFoundError(f"Directory {directory} does not exist")
 
-        export_dir.mkdir(parents=True, exist_ok=True)
+        await async_path.mkdir(export_dir, parents=True, exist_ok=True)
 
         # Cache that we've created this directory
         self._created_dirs.add(export_dir)

marimo/_server/sessions.py

@@ -75,6 +75,7 @@
 from marimo._server.types import ProcessLike
 from marimo._server.utils import print_, print_tabbed
 from marimo._types.ids import CellId_t, ConsumerId, SessionId
+from marimo._utils import async_path
 from marimo._utils.disposable import Disposable
 from marimo._utils.distributor import (
     ConnectionDistributor,
@@ -898,7 +899,7 @@ def _start_file_watcher_for_session(self, session: Session) -> None:
 
         async def on_file_changed(path: Path) -> None:
             # Skip if the session does not relate to the file
-            if session.app_file_manager.path != os.path.abspath(path):
+            if session.app_file_manager.path != await async_path.abspath(path):
                 return
 
             # Use the centralized file change handler
@@ -1148,7 +1149,7 @@ async def handle_file_change(
         This method reloads the notebook and sends appropriate operations
         to the frontend when a marimo file is modified.
         """
-        abs_file_path = os.path.abspath(file_path)
+        abs_file_path = await async_path.abspath(file_path)
 
         # Use a lock to prevent concurrent processing of the same file
         if abs_file_path not in self._file_change_locks:

marimo/_utils/async_path.py

@@ -195,6 +195,11 @@ async def expanduser(self) -> AsyncPath:
         result = await asyncio.to_thread(self._path.expanduser)
         return self.__class__(result)
 
+    async def absolute(self) -> AsyncPath:
+        """Return an absolute version of this path."""
+        result = await asyncio.to_thread(self._path.absolute)
+        return self.__class__(result)
+
     # Context manager support for opening files
 
     def open(
@@ -230,3 +235,42 @@ class AsyncWindowsPath(AsyncPath, PureWindowsPath):
 
     def __getattr__(self, name: str) -> Any:
         return super().__getattr__(name)  # type: ignore
+
+
+# Module-level convenience functions for compatibility with aio_path
+
+
+async def exists(path: StrPath) -> bool:
+    """Check if a path exists asynchronously."""
+    return await AsyncPath(path).exists()
+
+
+async def isfile(path: StrPath) -> bool:
+    """Check if a path is a file asynchronously."""
+    return await AsyncPath(path).is_file()
+
+
+async def isdir(path: StrPath) -> bool:
+    """Check if a path is a directory asynchronously."""
+    return await AsyncPath(path).is_dir()
+
+
+async def abspath(path: StrPath) -> str:
+    """Return absolute path asynchronously."""
+    result = await AsyncPath(path).absolute()
+    return str(result)
+
+
+async def normpath(path: str) -> str:
+    """Normalize a pathname asynchronously."""
+    return await asyncio.to_thread(os.path.normpath, path)
+
+
+async def mkdir(
+    path: StrPath,
+    mode: int = 0o777,
+    parents: bool = False,
+    exist_ok: bool = False,
+) -> None:
+    """Create a directory asynchronously."""
+    await AsyncPath(path).mkdir(mode=mode, parents=parents, exist_ok=exist_ok)

marimo/_utils/file_watcher.py

@@ -11,6 +11,7 @@
 
 from marimo import _loggers
 from marimo._dependencies.dependencies import DependencyManager
+from marimo._utils import async_path
 
 LOGGER = _loggers.marimo_logger()
 
@@ -79,7 +80,7 @@ def _get_modified(self) -> Optional[float]:
 
     async def _poll(self) -> None:
         while self._running:
-            if not os.path.exists(self.path):
+            if not await async_path.exists(self.path):
                 LOGGER.warning(f"File at {self.path} does not exist.")
                 raise FileNotFoundError(f"File at {self.path} does not exist.")
 

marimo/_utils/files.py

@@ -7,6 +7,8 @@
 from pathlib import Path
 from typing import TYPE_CHECKING, Union
 
+from marimo._utils import async_path
+
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator, Generator
 
@@ -107,12 +109,12 @@ async def async_expand_file_patterns(
     seen = set()
 
     for pattern in file_patterns:
-        if os.path.isfile(pattern):
+        if await async_path.isfile(pattern):
             path = Path(pattern)
             if path not in seen:
                 seen.add(path)
                 yield path
-        elif os.path.isdir(pattern):
+        elif await async_path.isdir(pattern):
             async for file_path in async_get_files(pattern):
                 if file_path not in seen:
                     seen.add(file_path)
@@ -124,7 +126,7 @@ async def async_expand_file_patterns(
                 root = _get_root(pattern)
 
                 # Get all files from root and filter by pattern
-                if os.path.isdir(root):
+                if await async_path.isdir(root):
                     async for file_path in async_get_files(root):
                         if (
                             fnmatch.fnmatch(str(file_path), pattern)

pixi.lock

@@ -362,7 +362,6 @@ ignore = [
     "PERF203", # try-except within a loop incurs performance overhead; not always possible
     "PERF401", # Use {message_str} to create a transformed list; at the cost of readability
     "PERF403", # Use a dictionary comprehension instead of a for-loop; at the cost of readability
-    "ASYNC240", # Async functions should not use os.path methods, use trio.Path or anyio.path
     # TODO: we should fix these, and enable this rule
     "PT011", # `pytest.raises(ValueError)` is too broad, set the `match` parameter or use a more specific exception
     "E501",  # Line too long, we still trim

pyproject.toml

@@ -10,3 +10,5 @@ echo "[check: format]"
 hatch run ruff format
 echo "[check: typecheck]"
 hatch run typecheck:check
+echo "[check: update-lock]"
+hatch run pixi lock

scripts/pycheck.sh

@@ -15,6 +15,7 @@
 import pytest
 
 from marimo._dependencies.dependencies import DependencyManager
+from marimo._utils import async_path
 from marimo._utils.platform import is_windows
 from tests._server.templates.utils import normalize_index_html
 from tests.mocks import snapshotter
@@ -323,7 +324,7 @@ async def test_export_watch(self, temp_marimo_file: str) -> None:
                 assert f"Watching {temp_marimo_file}" in line
                 break
 
-        assert not path.exists(temp_out_file)
+        assert not await async_path.exists(temp_out_file)
 
         # Modify file
         with open(temp_marimo_file, "a") as f:  # noqa: ASYNC230
@@ -653,7 +654,7 @@ async def test_export_watch_script(self, temp_marimo_file: str) -> None:
                 assert f"Watching {temp_marimo_file}" in line
                 break
 
-        assert not path.exists(temp_out_file)
+        assert not await async_path.exists(temp_out_file)
 
         # Modify file
         with open(temp_marimo_file, "a") as f:  # noqa: ASYNC230
@@ -668,7 +669,7 @@ async def test_export_watch_script(self, temp_marimo_file: str) -> None:
                 break
 
         await asyncio.sleep(0.1)
-        assert path.exists(temp_out_file)
+        assert await async_path.exists(temp_out_file)
 
     @pytest.mark.skipif(
         condition=DependencyManager.watchdog.has(),
@@ -771,7 +772,7 @@ async def test_export_watch_markdown(self, temp_marimo_file: str) -> None:
                 assert f"Watching {temp_marimo_file}" in line
                 break
 
-        assert not path.exists(temp_out_file)
+        assert not await async_path.exists(temp_out_file)
 
         # Modify file
         with open(temp_marimo_file, "a") as f:  # noqa: ASYNC230
@@ -786,7 +787,7 @@ async def test_export_watch_markdown(self, temp_marimo_file: str) -> None:
                 break
 
         await asyncio.sleep(0.1)
-        assert path.exists(temp_out_file)
+        assert await async_path.exists(temp_out_file)
 
     @pytest.mark.skipif(
         condition=DependencyManager.watchdog.has(),