bakefile 0.0.8__tar.gz → 0.0.10__tar.gz

{bakefile-0.0.8 → bakefile-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bakefile
-Version: 0.0.8
+Version: 0.0.10
 Summary: Add your description here
 Author: Wisaroot Lertthaweedech
 Author-email: Wisaroot Lertthaweedech <l.wisaroot@gmail.com>

{bakefile-0.0.8 → bakefile-0.0.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bakefile"
-version = "0.0.8" # use git tag
+version = "0.0.10" # use git tag
 description = "Add your description here"
 readme = "README.md"
 authors = [

{bakefile-0.0.8 → bakefile-0.0.10}/src/bake/manage/find_python.py

@@ -9,6 +9,8 @@ from bake.utils.exceptions import PythonNotFoundError
 
 logger = logging.getLogger(__name__)
 
+_NO_PROJECT_PYTHON_MSG = "No project Python found"
+
 
 def is_standalone_bakefile(bakefile_path: Path) -> bool:
     inline_metadata = read_inline(bakefile_path)
@@ -101,18 +103,33 @@ def _find_project_python(bakefile_path: Path) -> Path | None:
     # Check if stderr contains "Found `...` at `...` (...)"
     # where source is "active virtual environment" or "virtual environment"
     stderr = result.stderr.strip()
-    pattern = r"Found `[^`]+` at `[^`]+` \(([^)]+)\)"
+    pattern = r"Found `[^`]+` at `([^`]+)` \(([^)]+)\)"
     match = re.search(pattern, stderr)
 
-    if result.returncode == 0 and match:
-        source = match.group(1)
-        if source in {"active virtual environment", "virtual environment"}:
-            python_path = Path(result.stdout.strip())
-            logger.debug(f"Found project Python at {python_path} (source: {source})")
-            return python_path
+    if not (result.returncode == 0 and match):
+        logger.debug(_NO_PROJECT_PYTHON_MSG)
+        return None
 
-    logger.debug("No project Python found")
-    return None
+    source = match.group(2)
+    if source not in {"active virtual environment", "virtual environment"}:
+        logger.debug(_NO_PROJECT_PYTHON_MSG)
+        return None
+
+    python_path_from_log = Path(match.group(1))
+    python_path_from_stdout = Path(result.stdout.strip())
+    if python_path_from_log != python_path_from_stdout:
+        logger.debug(
+            "Python path mismatch between log and stdout",
+            extra={
+                "python_path_from_log": python_path_from_log,
+                "python_path_from_stdout": python_path_from_stdout,
+            },
+        )
+        logger.debug(_NO_PROJECT_PYTHON_MSG)
+        return None
+
+    logger.debug(f"Found project Python at {python_path_from_stdout} (source: {source})")
+    return python_path_from_stdout
 
 
 def _create_bakefile_venv(bakefile_path: Path) -> Path | None:

{bakefile-0.0.8 → bakefile-0.0.10}/src/bake/ui/run/splitter.py

@@ -1,3 +1,4 @@
+import errno
 import os
 import select
 import subprocess
@@ -46,37 +47,55 @@ class OutputSplitter:
             output_list.append(data)
         return True
 
-    def _read_pty(self, pty_fd: int, target, output_list, proc: subprocess.Popen):
-        """Read from PTY file descriptor in chunks and stream to output."""
+    def _read_pty_eio_safe(self, pty_fd: int) -> bytes | None:
+        """Read from PTY, treating EIO as EOF (returns None)."""
+        try:
+            return os.read(pty_fd, 4096)
+        except OSError as e:
+            if e.errno == errno.EIO:
+                return None
+            raise
+
+    def _try_immediate_read(self, pty_fd: int, target, output_list) -> bool:
+        """Try immediate non-blocking read. Returns True if should continue."""
+        import fcntl
+
+        flags = fcntl.fcntl(pty_fd, fcntl.F_GETFL)
+        fcntl.fcntl(pty_fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
+
+        data = self._read_pty_eio_safe(pty_fd)
+        if data is None or not self._handle_data(data, target, output_list):
+            fcntl.fcntl(pty_fd, fcntl.F_SETFL, flags)
+            return False
+
+        fcntl.fcntl(pty_fd, fcntl.F_SETFL, flags)
+        return True
+
+    def _blocking_pty_read(self, pty_fd: int, target, output_list) -> bool:
+        """Try select-based blocking read. Returns True if should continue."""
         import fcntl
 
+        flags = fcntl.fcntl(pty_fd, fcntl.F_GETFL)
+        fcntl.fcntl(pty_fd, fcntl.F_SETFL, flags)
+
+        ready, _, _ = select.select([pty_fd], [], [], 0.1)
+        if ready:
+            data = self._read_pty_eio_safe(pty_fd)
+            if data is None or not self._handle_data(data, target, output_list):
+                return False
+        return True
+
+    def _read_pty(self, pty_fd: int, target, output_list, proc: subprocess.Popen):
+        """Read from PTY file descriptor in chunks and stream to output."""
         try:
             while True:
-                # Try immediate non-blocking read first (catches fast-exiting processes)
                 try:
-                    # Set non-blocking mode
-                    flags = fcntl.fcntl(pty_fd, fcntl.F_GETFL)
-                    fcntl.fcntl(pty_fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
-
-                    data = os.read(pty_fd, 4096)
-                    if not self._handle_data(data, target, output_list):
+                    if not self._try_immediate_read(pty_fd, target, output_list):
                         break
-
-                    # Restore blocking mode
-                    fcntl.fcntl(pty_fd, fcntl.F_SETFL, flags)
                 except BlockingIOError:
-                    # No data available yet, restore blocking mode and wait with select
-                    fcntl.fcntl(pty_fd, fcntl.F_SETFL, flags)
-
-                    # Wait for data to be available
-                    ready, _, _ = select.select([pty_fd], [], [], 0.1)
-
-                    if ready:
-                        data = os.read(pty_fd, 4096)
-                        if not self._handle_data(data, target, output_list):
-                            break
+                    if not self._blocking_pty_read(pty_fd, target, output_list):
+                        break
 
-                # Check if process exited after reading data
                 if proc.poll() is not None:
                     self._drain_pty(pty_fd, target, output_list)
                     break

{bakefile-0.0.8 → bakefile-0.0.10}/src/bakelib/space/base.py

@@ -57,20 +57,16 @@ class BaseSpace(Bakebook):
                 help="Patterns to exclude",
             ),
         ] = None,
-        use_default_excludes: Annotated[
+        default_excludes: Annotated[
             bool,
-            typer.Option(
-                "--no-default-excludes",
-                help="Do not apply default exclude patterns",
-                is_flag=True,
-            ),
-        ] = False,
+            typer.Option(help="Apply default exclude patterns (.env, .cache)"),
+        ] = True,
     ) -> None:
         results = ctx.run("git clean -fdX -n", stream=False, dry_run=False, echo=True)
 
         exclude_patterns: set[str] = set(exclude_patterns if exclude_patterns else [])
 
-        if not use_default_excludes:
+        if default_excludes:
             exclude_patterns |= {".env", ".cache"}
 
         console.err.print(f"Exclude pattens: {exclude_patterns}")
@@ -175,7 +171,6 @@ class BaseSpace(Bakebook):
                 "--skip-test",
                 "-s",
                 help="Skip running tests",
-                is_flag=True,
             ),
         ] = False,
     ) -> None:

{bakefile-0.0.8 → bakefile-0.0.10}/src/bakelib/space/python.py

@@ -34,11 +34,20 @@ class PythonSpace(BaseSpace):
         ctx.run("uv run ty check --error-on-warning --no-progress .")
         ctx.run("uv run deptry .")
 
-    def _test(self, ctx: Context, *, tests_path: str, verbose: bool = False) -> None:
-        cmd = (
-            f"uv run pytest {tests_path} --cov=src --cov-report=html"
-            " --cov-report=term-missing --cov-report=xml"
-        )
+    def _test(
+        self,
+        ctx: Context,
+        *,
+        tests_paths: str | list[str],
+        verbose: bool = False,
+        coverage_report: bool = True,
+    ) -> None:
+        paths = tests_paths if isinstance(tests_paths, str) else " ".join(tests_paths)
+
+        cmd = f"uv run pytest {paths}"
+
+        if coverage_report:
+            cmd += " --cov=src --cov-report=html --cov-report=term-missing --cov-report=xml"
 
         if verbose:
             cmd += " -s -v"
@@ -53,20 +62,20 @@ class PythonSpace(BaseSpace):
         integration_tests_path = "tests/integration/"
         if Path(integration_tests_path).exists():
             tests_path = integration_tests_path
-            self._test(ctx, tests_path=tests_path, verbose=verbose)
+            self._test(ctx, tests_paths=tests_path, verbose=verbose)
         else:
             self._no_implementation(ctx)
 
     def test(self, ctx: Context) -> None:
         unit_tests_path = "tests/unit/"
         tests_path = unit_tests_path if Path(unit_tests_path).exists() else "tests/"
-        self._test(ctx, tests_path=tests_path)
+        self._test(ctx, tests_paths=tests_path)
 
     def test_all(self, ctx: Context) -> None:
         unit_tests_path = "tests/unit/"
         if Path(unit_tests_path).exists():
             tests_path = "tests/"
-            self._test(ctx, tests_path=tests_path)
+            self._test(ctx, tests_paths=tests_path)
         else:
             self._no_implementation(ctx)