bakefile 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

bake/ui/run/splitter.py

@@ -0,0 +1,249 @@
+import os
+import select
+import subprocess
+import sys
+import threading
+import time
+
+# No PTY locks needed - each thread reads from its own PTY fd independently
+# Locks were causing race conditions where threads waited while their process exited
+
+
+class OutputSplitter:
+    def __init__(
+        self,
+        stream: bool = True,
+        capture: bool = True,
+        pty_fd: int | None = None,
+        stderr_pty_fd: int | None = None,
+        encoding: str | None = None,
+    ):
+        self._stream = stream
+        self._capture = capture
+        self._pty_fd = pty_fd
+        self._stderr_pty_fd = stderr_pty_fd
+        self._encoding = encoding
+        self._stdout_data = b""
+        self._stderr_data = b""
+
+    def _read_stream(self, stream, target, output_list):
+        for line in iter(stream.readline, b""):
+            if self._stream:
+                target.buffer.write(line)
+                target.buffer.flush()
+            if self._capture:
+                output_list.append(line)
+        stream.close()
+
+    def _handle_data(self, data: bytes, target, output_list) -> bool:
+        """Handle data chunk: return False if data is empty (EOF)."""
+        if not data:
+            return False
+        if self._stream:
+            target.buffer.write(data)
+            target.buffer.flush()
+        if self._capture:
+            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."""
+        import fcntl
+
+        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):
+                        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
+
+                # Check if process exited after reading data
+                if proc.poll() is not None:
+                    self._drain_pty(pty_fd, target, output_list)
+                    break
+        finally:
+            os.close(pty_fd)
+
+    def _read_pty_data(self, pty_fd: int, target, output_list) -> bool:
+        """Read and handle available PTY data. Returns False on EOF/error."""
+        try:
+            data = os.read(pty_fd, 4096)
+            return self._handle_data(data, target, output_list)
+        except OSError:
+            return False
+
+    def _try_select_read(self, pty_fd: int, timeout: float) -> tuple[bool, bool]:
+        """Try to read using select.select().
+
+        Returns:
+            (success, has_data): success if select worked, has_data if ready
+        """
+        try:
+            ready, _, _ = select.select([pty_fd], [], [], timeout)
+            return True, bool(ready)
+        except OSError:
+            # On Windows, select.select() raises OSError for non-socket file descriptors
+            return False, False
+
+    def _read_and_handle(self, pty_fd: int, target, output_list) -> bool:
+        """Read from PTY and handle data.
+
+        Returns:
+            True if data was handled, False if EOF/error
+        """
+        try:
+            data = os.read(pty_fd, 4096)
+            return self._handle_data(data, target, output_list)
+        except OSError:
+            return False
+
+    def _handle_data_ready(self, pty_fd: int, target, output_list) -> bool:
+        """Handle data ready from select.
+
+        Returns:
+            True if should continue draining, False if done
+        """
+        return self._read_and_handle(pty_fd, target, output_list)
+
+    def _handle_timeout(
+        self,
+        pty_fd: int,
+        target,
+        output_list,
+        select_works: bool,
+        consecutive_timeouts: int,
+    ) -> tuple[bool, int]:
+        """Handle timeout when no data ready.
+
+        Returns:
+            (should_continue, new_timeout_count)
+        """
+        # Try direct read after 2 consecutive timeouts or if select doesn't work
+        if not select_works or consecutive_timeouts >= 2:
+            if not self._read_and_handle(pty_fd, target, output_list):
+                return False, 0
+            return True, 0  # Got data, reset timeout counter
+        return True, consecutive_timeouts + 1
+
+    def _drain_pty(self, pty_fd: int, target, output_list):
+        """Drain remaining data from PTY after process exits.
+
+        We need to handle OS timing: proc.poll() may return exit code before the
+        PTY buffer is fully flushed. We use select to wait for data with increasing
+        timeouts, and also try direct reads as a fallback in case select doesn't
+        detect readiness (e.g., in tests with mocked os.read or on Windows with
+        non-socket file descriptors).
+        """
+        time.sleep(0.005)
+
+        timeout = 0.05
+        consecutive_timeouts = 0
+        max_timeouts = 4
+        select_works = True
+
+        try:
+            while consecutive_timeouts < max_timeouts:
+                # Check if data is ready via select
+                if select_works:
+                    select_works, ready = self._try_select_read(pty_fd, timeout)
+                else:
+                    ready = False
+
+                if ready:
+                    # Data ready - read and handle
+                    if not self._handle_data_ready(pty_fd, target, output_list):
+                        return
+                    consecutive_timeouts = 0
+                    timeout = 0.02
+                    continue
+
+                # No data ready - increment timeout and try direct read
+                timeout = min(timeout * 1.5, 0.2)
+
+                should_continue, consecutive_timeouts = self._handle_timeout(
+                    pty_fd, target, output_list, select_works, consecutive_timeouts
+                )
+                if not should_continue:
+                    return
+        except OSError:
+            pass
+
+    def attach(self, proc: subprocess.Popen):
+        threads = []
+
+        # Handle PTY stdout (for color-preserving output on Unix)
+        if self._pty_fd is not None:
+            stdout_list = []
+            t = threading.Thread(
+                target=self._read_pty, args=(self._pty_fd, sys.stdout, stdout_list, proc)
+            )
+            t.daemon = True
+            t.start()
+            threads.append((t, stdout_list, "stdout"))
+
+        # Handle regular stdout
+        elif proc.stdout:
+            stdout_list = []
+            t = threading.Thread(
+                target=self._read_stream, args=(proc.stdout, sys.stdout, stdout_list)
+            )
+            t.daemon = True
+            t.start()
+            threads.append((t, stdout_list, "stdout"))
+
+        # Handle PTY stderr (for color-preserving stderr on Unix)
+        if self._stderr_pty_fd is not None:
+            stderr_list = []
+            t = threading.Thread(
+                target=self._read_pty, args=(self._stderr_pty_fd, sys.stderr, stderr_list, proc)
+            )
+            t.daemon = True
+            t.start()
+            threads.append((t, stderr_list, "stderr"))
+
+        # Handle stderr (regular pipe) - use separate if, not elif
+        if proc.stderr:
+            stderr_list = []
+            t = threading.Thread(
+                target=self._read_stream, args=(proc.stderr, sys.stderr, stderr_list)
+            )
+            t.daemon = True
+            t.start()
+            threads.append((t, stderr_list, "stderr"))
+
+        return threads
+
+    def finalize(self, threads):
+        for t, data_list, name in threads:
+            t.join()
+            if name == "stdout":
+                self._stdout_data = b"".join(data_list)
+            else:
+                self._stderr_data = b"".join(data_list)
+
+    @property
+    def stdout(self) -> bytes:
+        return self._stdout_data
+
+    @property
+    def stderr(self) -> bytes:
+        return self._stderr_data

bake/ui/run/uv.py

@@ -0,0 +1,83 @@
+import subprocess
+from pathlib import Path
+from typing import Literal, overload
+
+from uv import find_uv_bin
+
+from bake.ui import console
+from bake.ui.run.run import run
+
+
+@overload
+def run_uv(
+    cmd: list[str] | tuple[str, ...],
+    *,
+    capture_output: Literal[True] = True,
+    check: bool = True,
+    cwd: Path | str | None = None,
+    stream: bool = False,
+    shell: bool | None = None,
+    echo: bool = True,
+    dry_run: bool = False,
+    keep_temp_file: bool = False,
+    env: dict[str, str] | None = None,
+    _encoding: str | None = None,
+    **kwargs,
+) -> subprocess.CompletedProcess[str]: ...
+
+
+@overload
+def run_uv(
+    cmd: list[str] | tuple[str, ...],
+    *,
+    capture_output: Literal[False],
+    check: bool = True,
+    cwd: Path | str | None = None,
+    stream: bool = False,
+    echo: bool = True,
+    dry_run: bool = False,
+    keep_temp_file: bool = False,
+    env: dict[str, str] | None = None,
+    _encoding: str | None = None,
+    **kwargs,
+) -> subprocess.CompletedProcess[None]: ...
+
+
+def run_uv(
+    cmd: list[str] | tuple[str, ...],
+    *,
+    capture_output: bool = True,
+    check: bool = True,
+    cwd: Path | str | None = None,
+    stream: bool = False,
+    echo: bool = True,
+    dry_run: bool = False,
+    keep_temp_file: bool = False,
+    env: dict[str, str] | None = None,
+    _encoding: str | None = None,
+    **kwargs,
+) -> subprocess.CompletedProcess[str] | subprocess.CompletedProcess[None]:
+    uv_bin = find_uv_bin()
+
+    # Build display string: "uv" + command parts (no full binary path)
+    display_cmd = "uv " + " ".join(cmd)
+
+    # Echo command to console if requested
+    if echo:
+        console.cmd(display_cmd)
+
+    # Call run with full uv binary path, echo=False (already displayed), pass through options
+    return run(
+        [uv_bin, *cmd],
+        capture_output=capture_output,
+        check=check,
+        cwd=cwd,
+        stream=stream,
+        shell=False,
+        echo=False,
+        dry_run=dry_run,
+        keep_temp_file=keep_temp_file,
+        env=env,
+        _encoding=_encoding,
+        **kwargs,
+    )

bake/ui/style.py

@@ -0,0 +1,2 @@
+def code(message: str) -> str:
+    return f"`[cyan]{message}[/cyan]`"

bake/utils/__init__.py

@@ -0,0 +1,11 @@
+from bake.utils.constants import DEFAULT_BAKEBOOK_NAME, DEFAULT_FILE_NAME
+from bake.utils.env import should_use_colors
+from bake.utils.exceptions import BakebookError, BaseBakefileError
+
+__all__ = [
+    "DEFAULT_BAKEBOOK_NAME",
+    "DEFAULT_FILE_NAME",
+    "BakebookError",
+    "BaseBakefileError",
+    "should_use_colors",
+]

bake/utils/constants.py

@@ -0,0 +1,21 @@
+from pathlib import Path
+
+# Default value
+DEFAULT_CHDIR = Path(".")
+DEFAULT_FILE_NAME = "bakefile.py"
+DEFAULT_BAKEBOOK_NAME = "bakebook"
+DEFAULT_IS_CHAIN_COMMAND = False
+
+# CLI command names
+CMD_BAKE = "bake"
+CMD_BAKEFILE = "bakefile"
+CMD_INIT = "init"
+CMD_ADD_INLINE = "add-inline"
+CMD_LINT = "lint"
+
+# Bakefile app command name
+GET_BAKEFILE_OBJECT = "get_bakefile_object"
+
+# Others
+BAKEBOOK_NAME_IN_SAMPLES = "__bakebook__"
+BAKE_COMMAND_KWARGS = "_bake_command_kwargs"

{bakefile → bake/utils}/env.py

@@ -2,7 +2,9 @@ import os
 
 ENV_NO_COLOR = "NO_COLOR"
 
+_BAKE_REINVOKED = "_BAKE_REINVOKED"
+
 
 def should_use_colors() -> bool:
     value = os.environ.get(ENV_NO_COLOR)
-    return not (value == "" or value is None)
+    return value == "" or value is None

bake/utils/exceptions.py

@@ -0,0 +1,17 @@
+"""Custom exceptions for bakefile."""
+
+
+class BaseBakefileError(Exception):
+    """Base exception for all bakefile errors."""
+
+
+class BakebookError(BaseBakefileError):
+    """Exception raised when bakebook cannot be loaded or validated (unexpected error)."""
+
+
+class BakefileNotFoundError(BakebookError):
+    """Exception raised when bakefile.py is not found (expected/suppressable error)."""
+
+
+class PythonNotFoundError(BaseBakefileError):
+    """Exception raised when Python executable cannot be found or created."""

{bakefile-0.0.4.dist-info → bakefile-0.0.6.dist-info}/METADATA

@@ -1,12 +1,25 @@
 Metadata-Version: 2.3
 Name: bakefile
-Version: 0.0.4
+Version: 0.0.6
 Summary: Add your description here
 Author: Wisaroot Lertthaweedech
 Author-email: Wisaroot Lertthaweedech <l.wisaroot@gmail.com>
+Requires-Dist: beautysh>=6.4.2
+Requires-Dist: click>=8.3.1
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: orjson>=3.11.5
+Requires-Dist: pydantic-settings>=2.0.0
 Requires-Dist: pydantic>=2.12.5
-Requires-Dist: typer>=0.0.1
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: rich>=14.2.0
+Requires-Dist: ruff>=0.14.10
+Requires-Dist: tomli>=2.0.0 ; python_full_version < '3.11'
+Requires-Dist: ty>=0.0.8
+Requires-Dist: typer>=0.21.0
+Requires-Dist: uv>=0.9.20
+Requires-Dist: pathspec>=1.0.3 ; extra == 'lib'
 Requires-Python: >=3.10
+Provides-Extra: lib
 Description-Content-Type: text/markdown
 
 [![tests](https://img.shields.io/github/actions/workflow/status/wislertt/bakefile/cd.yml?branch=main&label=tests&logo=github)](https://github.com/wislertt/bakefile/actions/workflows/cd.yml)

bakefile-0.0.6.dist-info/RECORD

@@ -0,0 +1,63 @@
+bake/__init__.py,sha256=ikK9AMD9ELxzcH3_JRZt3bnNLS0vCzlaH82gpGi_dNE,356
+bake/bakebook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bake/bakebook/bakebook.py,sha256=o1sp8Wewxdqr7k12qT-Q4ZrKQ7c7jDliiNCYrVG93NA,2939
+bake/bakebook/decorator.py,sha256=t2I6Pf1vdTk7k8lTzZCqq71-hzcXFvFYbuFV_Wvg45Q,1545
+bake/bakebook/get.py,sha256=fx5WV66OIBrywPN0thePXAJk2gt7wvTVAxYQqZ_PMao,5807
+bake/cli/__init__.py,sha256=da1PTClDMl-IBkrSvq6JC1lnS-K_BASzCvxVhNxN5Ls,13
+bake/cli/bake/__init__.py,sha256=CJokSP1t1KXaIqjkjFQ8_gbaSZ9RRB4YdemIoSTqRcI,56
+bake/cli/bake/__main__.py,sha256=5Ui5_OD1-oG1ou6boak63EPQDmRsW9sGOVVDgXJaNec,133
+bake/cli/bake/main.py,sha256=Lr6eyfaf4-zDRrF0GK9bjjFWop66ydewV5tNUluDd9M,2262
+bake/cli/bake/reinvocation.py,sha256=Ifqc8ZAM7NMyrKU2jkmw1agCEI-Sx7yvLLBiFRi23_0,1985
+bake/cli/bakefile/__init__.py,sha256=_zD3rXQHLr6EWHADdPLAmnc2A5C3dhmBuvP5uJ-_A58,60
+bake/cli/bakefile/__main__.py,sha256=FVntzkZdzdygSWjMzyneXCXsM-MDTPmC3GUk4JZiYFU,137
+bake/cli/bakefile/add_inline.py,sha256=V98T50SLMPqnWVtyEO_6hL17r4n3ZtkSC8NSEqdyHzc,919
+bake/cli/bakefile/export.py,sha256=m9X0u6FgbjUzneQuh39H1CaFUT444jOPTFBNjnjs_Dg,6326
+bake/cli/bakefile/find_python.py,sha256=J2HDs_nfNODqCHBZCNM64ESB4kVZK-C04i-KNmVUoSs,539
+bake/cli/bakefile/init.py,sha256=0QuvADFOZZUBN2BUJfK90aEY1oUzoSNVRiljlUSjLu0,1825
+bake/cli/bakefile/lint.py,sha256=DJkIJNBOef6JvgwQ3iL9jTrLqgUyn66Mhv6cuAgqXk0,2509
+bake/cli/bakefile/main.py,sha256=jbpzNQa55thbzhpcmEtys1M1CvNUJBvi5UmgVzSbOM8,1414
+bake/cli/bakefile/uv.py,sha256=PMFG3BdofzGWkor4fMEi3GE4G7hGtclCgPm2xlaPDso,4013
+bake/cli/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bake/cli/common/app.py,sha256=_XzBOy0OK2GB14E-cyfLV6CBCn70G62QqjUscj_DHfA,1443
+bake/cli/common/callback.py,sha256=NmrZUl5eRr95nluomTwcKjTU7dSKjWcQVli5VEdZk-4,439
+bake/cli/common/context.py,sha256=RtFHUDCZLcD88Ys17u_zXoHUq-12jkoXc9f_D4jh_7M,3871
+bake/cli/common/exception_handler.py,sha256=2vLbqMeZlLxKqNWUkTs3cA-8l6IjK0dU3SyZlRb96YI,1759
+bake/cli/common/obj.py,sha256=ShDsQtHCxex17IrKb9kSdC1t459qBsam53SFCUB_DSA,7094
+bake/cli/common/params.py,sha256=rhLa34SY92nXfUaKo0SQMKK__xRnrmHejHa25tRyKdg,2002
+bake/cli/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bake/cli/utils/version.py,sha256=aiweLD0vDezBlJAcCC99oMms71WGD9CWSJuZ4i3VLHA,390
+bake/manage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bake/manage/add_inline.py,sha256=yefHmF33ghCB8NZ-v61ybeVsaeE8iDFvfRGeTAKg4I8,2245
+bake/manage/find_python.py,sha256=oVmd8KaSsgDQWHuGZpYiQx-DHn50P9EkRi6-YIad99E,7165
+bake/manage/lint.py,sha256=OqwYFF8GGvzHGVPuJcWMRAv5esXEIX4nQXdGcChnkqA,2394
+bake/manage/run_uv.py,sha256=QzlKeVpr20dXNDcwUgyJqnXT4MofRqK-6XkWpzBbUhE,3234
+bake/manage/write_bakefile.py,sha256=efGViLk7sh-QX9Mox7yQw_A1Tp7EOuc_vmSTbFmXUm0,736
+bake/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bake/samples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bake/samples/simple.py,sha256=hP2TW-D7BQBGJseqRPpilxkoQ8ScTuZZePICupyvFKA,155
+bake/ui/__init__.py,sha256=6OhZVKjfC9aumbhraxkGtx7KLpV1ouepeHRA2dUVoSo,209
+bake/ui/console.py,sha256=C5wrbsOc-wwcx0hGmCozHvGCNTWgGhsh-5vxl880xS4,1689
+bake/ui/logger/__init__.py,sha256=bup2cssTHhergh47s6uYbGtY2dJNxlKKH6otBc4ECFM,728
+bake/ui/logger/capsys.py,sha256=KZL6k7Werp_8styfJKfIvQyv0-gJq54vY3hSJFIacEM,5267
+bake/ui/logger/setup.py,sha256=OrX9UiY0iBGfWWfhMJCdfqCRJsL5yC3rIdIEOn7rveo,1377
+bake/ui/logger/utils.py,sha256=dcppxoS_pX92AFcHIerJGI2_JBHBNghRQmQqlZmmj2Q,7218
+bake/ui/params.py,sha256=yNDChJQkbeZSxQzXTSBrAPCbwsJ5zOK4s4sFHQPSnHs,140
+bake/ui/run/__init__.py,sha256=A671l5YVTRAtS47ewvaMCNwPRim_Wkof1am0WibxA2I,205
+bake/ui/run/run.py,sha256=qfDgy-YqcexJyHhSjnQ5IXipBDoK-umwKq-wAn8ZITU,17504
+bake/ui/run/script.py,sha256=fk7KiDklYDYpFGkH3wu-hZGI4OnvgcB8z5jtNt41Hg0,2263
+bake/ui/run/splitter.py,sha256=sQt0prFGR6WCCMDr1wqk1GXBQmUSV9MNHzYzMu9Pwik,8643
+bake/ui/run/uv.py,sha256=3NpnjgAwQNijJiUT_H6U-3mTHQgBZPlJbNWEeYCZY1g,2077
+bake/ui/style.py,sha256=v9dferzV317Acb0GHpVK_niCj_s2HtL-yiToBZtXky4,70
+bake/utils/__init__.py,sha256=GUu_xlJy3RAHo6UcZXu2x4khxGqLHMA9Zos4hDiQIY8,326
+bake/utils/constants.py,sha256=mRq5IpgOTdlHOTWPq5dx0A-LwhiFkWgYHfr8cLWG7rY,471
+bake/utils/env.py,sha256=bzNdH_2bTJebQaw7D0uVJv-vzZ-uYl0pCAS8oQONVsA,190
+bake/utils/exceptions.py,sha256=pwsQnKH5ljMNxmqEREutXa7TohiBHATHg_D5kQUPT30,519
+bakelib/__init__.py,sha256=sZeRiNINWL8xI3b1MxkGyF3f2lKMjyhjKt7qyCCAufs,126
+bakelib/space/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bakelib/space/base.py,sha256=bJlpPkP85xBu8X5fJoVaHrMzX27rQrYTEPSObwBANJ8,6008
+bakelib/space/python.py,sha256=UEr4Jo76T2cbAQdClVu7RvJYzflLE9i_xFohcNhjFjw,2597
+bakelib/space/utils.py,sha256=xx4X_txhDH_p97CKJ-KuvFpgfNBC0y_din1IBlUVusU,2983
+bakefile-0.0.6.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
+bakefile-0.0.6.dist-info/entry_points.txt,sha256=Ecvvh7BYHCPJ0UdntrDc3Od6AZdRPXN5Z7o_7ok_0Qw,107
+bakefile-0.0.6.dist-info/METADATA,sha256=6tec3_eRxbtTAsdHJHUC1Vo4yIondUR_U28oRq2Cp1c,2331
+bakefile-0.0.6.dist-info/RECORD,,

{bakefile-0.0.4.dist-info → bakefile-0.0.6.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.18
+Generator: uv 0.9.26
 Root-Is-Purelib: true
-Tag: py3-none-any
+Tag: py3-none-any

bakefile-0.0.6.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+bake = bake.cli.bake:main
+bakefile = bake.cli.bakefile:main
+bf = bake.cli.bakefile:main
+

bakelib/__init__.py

@@ -0,0 +1,4 @@
+from bakelib.space.base import BaseSpace
+from bakelib.space.python import PythonSpace
+
+__all__ = ["BaseSpace", "PythonSpace"]