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

bake/ui/logger/__init__.py

@@ -0,0 +1,33 @@
+from loguru import logger
+
+from bake.ui.logger.capsys import (
+    capsys_to_logs,
+    capsys_to_logs_pretty,
+    capture_to_logs,
+    capture_to_logs_pretty,
+    count_message_in_logs,
+    find_log,
+    has_message_in_logs,
+    has_messages_in_logs,
+    parse_pretty_log,
+    strip_ansi,
+)
+from bake.ui.logger.setup import setup_logging
+from bake.ui.logger.utils import UNPARSABLE_LINE, LogKey
+
+__all__ = [
+    "UNPARSABLE_LINE",
+    "LogKey",
+    "capsys_to_logs",
+    "capsys_to_logs_pretty",
+    "capture_to_logs",
+    "capture_to_logs_pretty",
+    "count_message_in_logs",
+    "find_log",
+    "has_message_in_logs",
+    "has_messages_in_logs",
+    "logger",
+    "parse_pretty_log",
+    "setup_logging",
+    "strip_ansi",
+]

bake/ui/logger/capsys.py

@@ -0,0 +1,158 @@
+import json
+import re
+from typing import TYPE_CHECKING, Any
+
+import orjson
+
+from bake.ui.logger.utils import UNPARSABLE_LINE, LogKey, LogType
+
+if TYPE_CHECKING:
+    import _pytest.capture
+    import pytest
+
+
+def has_required_keys(log: LogType) -> bool:
+    return LogKey.required_keys().issubset(log.keys())
+
+
+def strip_ansi(text: str) -> str:
+    """Remove ANSI color codes from text."""
+    ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+    return ansi_escape.sub("", text)
+
+
+def _safe_parse_dict_str(dict_str: str, unparsed_key: str = "_unparsed") -> dict[str, Any]:
+    try:
+        return orjson.loads(dict_str)
+    except (TypeError, ValueError):
+        # For malformed JSON, preserve original string for debugging
+        return {unparsed_key: dict_str}
+
+
+def parse_pretty_log(pretty_output: str) -> list[LogType]:
+    """Parse pretty log format back into structured log entries."""
+    # Strip ANSI codes first
+    clean_output = strip_ansi(pretty_output)
+
+    log_pattern = re.compile(
+        r"(?P<timestamp>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3} [+-]\d{2}:\d{2}) \| "
+        r"(?P<level>\w+)\s+\| "
+        r"(?P<name>[\w.]+):(?P<function>[\w_<>]+):(?P<line>\d+) - "
+        r"(?P<message>.+?) - "
+        r"(?P<extra>\{.*?\}) - "
+        r"(?P<default_extra>\{.*?\})"
+        r"(?:\n\n(?P<exception>Traceback[\s\S]*?))?(?=\n\n\d{4}-\d{2}-\d{2}|\n\d{4}-\d{2}-\d{2}|$)",
+        re.DOTALL,
+    )
+
+    matches = log_pattern.findall(clean_output)
+    parsed_logs = []
+    for match in matches:
+        # Unpack the match tuple (findall returns tuples, not match objects)
+        timestamp, level, name, function, line, message, extra, default_extra, exception = match
+
+        # Parse extra fields safely (handles non-literal values like PosixPath)
+        extra_dict = _safe_parse_dict_str(extra, "_unparsed_extra")
+        default_extra_dict = _safe_parse_dict_str(default_extra, "_unparsed_default_extra")
+
+        log_data = {
+            LogKey.TIMESTAMP.value: timestamp,
+            LogKey.LEVEL.value: level,
+            LogKey.NAME.value: name,
+            LogKey.MODULE.value: name.split(".")[-1],
+            LogKey.FUNCTION_NAME.value: function,
+            LogKey.LINE_NO.value: int(line),
+            LogKey.MESSAGE.value: message,
+            **extra_dict,
+            **default_extra_dict,
+        }
+
+        # Add exception if present
+        if exception:
+            log_data[LogKey.EXCEPTION.value] = exception
+
+        # Map default_extra to LogKey fields
+        if "process_name" in default_extra_dict:
+            log_data[LogKey.PROCESS_NAME.value] = default_extra_dict["process_name"]
+        if "file_name" in default_extra_dict:
+            log_data[LogKey.FILE_NAME.value] = default_extra_dict["file_name"]
+        if "thread_name" in default_extra_dict:
+            log_data[LogKey.THREAD_NAME.value] = default_extra_dict["thread_name"]
+
+        parsed_logs.append(log_data)
+
+    return parsed_logs
+
+
+def capture_to_logs(
+    capture: "_pytest.capture.CaptureResult[str]", preserve_unparsable: bool = False
+) -> list[LogType]:
+    log_lines = capture.err.strip().split("\n")
+    parsed_logs = []
+
+    for line in log_lines:
+        if not line:
+            continue
+        try:
+            parsed_log = json.loads(line)
+            if not has_required_keys(parsed_log):
+                if preserve_unparsable:
+                    parsed_logs.append({UNPARSABLE_LINE: line})
+                continue
+            parsed_logs.append(parsed_log)
+        except json.JSONDecodeError:
+            if preserve_unparsable:
+                parsed_logs.append({UNPARSABLE_LINE: line})
+            continue
+    return parsed_logs
+
+
+def capture_to_logs_pretty(capture: "_pytest.capture.CaptureResult[str]") -> list[LogType]:
+    pretty_output = capture.err
+    if not pretty_output.strip():
+        return []
+    return parse_pretty_log(pretty_output)
+
+
+def capsys_to_logs(
+    capsys: "pytest.CaptureFixture[str]", preserve_unparsable: bool = False
+) -> list[LogType]:
+    capture = capsys.readouterr()
+    return capture_to_logs(capture=capture, preserve_unparsable=preserve_unparsable)
+
+
+def capsys_to_logs_pretty(capsys: "pytest.CaptureFixture[str]") -> list[LogType]:
+    capture = capsys.readouterr()
+    return capture_to_logs_pretty(capture=capture)
+
+
+def has_message_in_logs(logs: list[LogType], message: str) -> bool:
+    return any(log for log in logs if re.search(message, log[LogKey.MESSAGE.value]))
+
+
+def has_messages_in_logs(logs: list[LogType], messages: list[str]) -> bool:
+    if not messages:
+        return True
+
+    log_messages = [log[LogKey.MESSAGE.value] for log in logs]
+    msg_idx = 0
+
+    for log_msg in log_messages:
+        if not re.search(messages[msg_idx], log_msg):
+            continue
+        msg_idx += 1
+        if msg_idx == len(messages):
+            return True
+
+    return False
+
+
+def count_message_in_logs(logs: list[LogType], message: str) -> int:
+    return sum(1 for log in logs if re.search(message, log[LogKey.MESSAGE.value]))
+
+
+def find_log(logs: list[LogType], pattern: str, index: int = 0) -> LogType:
+    matches = (log for log in logs if re.search(pattern, log[LogKey.MESSAGE.value]))
+    for _ in range(index):
+        next(matches)
+    return next(matches)

bake/ui/logger/setup.py

@@ -0,0 +1,53 @@
+import logging
+import sys
+from contextvars import ContextVar
+from typing import TYPE_CHECKING, Any, cast
+
+from loguru import logger
+
+from .utils import (
+    InterceptHandler,
+    JsonSink,
+    PrettyLogFormatter,
+    get_global_min_log_level,
+    reset_all_logging_states,
+)
+
+if TYPE_CHECKING:
+    from loguru import FilterDict, FormatFunction
+
+
+def setup_logging(
+    level_per_module: "FilterDict | None" = None,
+    thread_local_context: dict[str, ContextVar[Any]] | None = None,
+    is_pretty_log: bool = False,
+) -> None:
+    if level_per_module is None:
+        level_per_module = {"": logging.WARNING}
+
+    if thread_local_context is None:
+        thread_local_context = {}
+
+    global_min_log_level = get_global_min_log_level(level_per_module)
+
+    reset_all_logging_states()
+    logger.remove()
+    logging.basicConfig(handlers=[InterceptHandler()], level=0, force=True)
+
+    if is_pretty_log:
+        sink = sys.stderr
+        formatter: FormatFunction | str = cast(
+            "FormatFunction",
+            PrettyLogFormatter(thread_local_context=thread_local_context),
+        )
+    else:
+        sink = JsonSink(thread_local_context=thread_local_context)
+        formatter: FormatFunction | str = ""
+
+    logger.add(
+        sink=sink,
+        format=formatter,
+        level=global_min_log_level,
+        filter=level_per_module,
+        backtrace=False,
+    )

bake/ui/logger/utils.py

@@ -0,0 +1,215 @@
+import inspect
+import logging
+import sys
+from contextvars import ContextVar
+from enum import Enum
+from typing import TYPE_CHECKING, Any, ClassVar, TextIO
+
+import orjson
+from loguru import logger
+from loguru._better_exceptions import ExceptionFormatter
+from loguru._simple_sinks import StreamSink
+
+if TYPE_CHECKING:
+    from loguru import FilterDict, Message, Record
+
+    class ExtendedRecord(Record):
+        default_extra: dict[str, Any]
+        extra_json: str
+        default_extra_json: str
+
+
+UNPARSABLE_LINE = "unparsable_line"
+LogType = dict[str, Any]
+
+
+class LogKey(str, Enum):
+    TIMESTAMP = "timestamp"
+    LEVEL = "level"
+    MESSAGE = "message"
+    NAME = "name"
+    PROCESS_NAME = "process_name"
+    FILE_NAME = "file_name"
+    FUNCTION_NAME = "function_name"
+    LINE_NO = "line_no"
+    MODULE = "module"
+    THREAD_NAME = "thread_name"
+    EXCEPTION = "exc_info"
+
+    @classmethod
+    def required_keys(cls) -> frozenset[str]:
+        return frozenset(key.value for key in LogKey if key is not LogKey.EXCEPTION)
+
+
+def get_global_min_log_level(level_per_module: "FilterDict") -> int:
+    if "" not in level_per_module:
+        raise ValueError("Missing empty string key for default logging level")
+
+    if not all(isinstance(v, int) for v in level_per_module.values()):
+        raise ValueError("All values in the dictionary must be of type 'int'")
+
+    global_min_log_level = min(v for v in level_per_module.values() if isinstance(v, int))
+
+    return global_min_log_level
+
+
+def reset_all_logging_states():
+    logging.root.handlers.clear()
+    logging.root.setLevel(logging.NOTSET)
+    for _logger in logging.Logger.manager.loggerDict.values():
+        if isinstance(_logger, logging.Logger):
+            _logger.handlers.clear()
+            _logger.setLevel(logging.NOTSET)
+
+
+class InterceptHandler(logging.Handler):
+    default_log_record_attr: ClassVar[set[str]] = {
+        "args",
+        "asctime",
+        "created",
+        "exc_info",
+        "exc_text",
+        "filename",
+        "funcName",
+        "levelname",
+        "levelno",
+        "lineno",
+        "module",
+        "msecs",
+        "message",
+        "msg",
+        "name",
+        "pathname",
+        "process",
+        "processName",
+        "relativeCreated",
+        "stack_info",
+        "taskName",
+        "thread",
+        "threadName",
+    }
+
+    def emit(self, record: logging.LogRecord) -> None:
+        # Get corresponding Loguru level if it exists.
+        try:
+            level: str | int = logger.level(record.levelname).name
+        except ValueError:
+            level = record.levelno
+
+        # Find caller from where originated the logged message.
+        frame, depth = inspect.currentframe(), 0
+        while frame:
+            filename = frame.f_code.co_filename
+            is_logging = filename == logging.__file__
+            is_frozen = "importlib" in filename and "_bootstrap" in filename
+            if depth > 0 and not (is_logging or is_frozen):
+                break
+            frame = frame.f_back
+            depth += 1
+
+        extra = {k: v for k, v in record.__dict__.items() if k not in self.default_log_record_attr}
+        logger.opt(depth=depth, exception=record.exc_info).bind(**extra).log(
+            level, record.getMessage()
+        )
+
+
+def to_json_serializable(data: Any) -> Any:
+    return orjson.dumps(data, default=str).decode()
+
+
+def flatten_extra(record_extra: dict[str, Any]) -> dict[str, Any]:
+    # Maintain consistent extra= API between standard logging and Loguru
+    # Flatten Loguru's nested structure to match logging module behavior
+    if "extra" in record_extra:
+        nested_extra = record_extra.pop("extra")
+        record_extra.update(
+            {f"extra_{k}" if k in record_extra else k: v for k, v in nested_extra.items()}
+        )
+
+    return record_extra
+
+
+class PrettyLogFormatter:
+    def __init__(self, thread_local_context: dict[str, ContextVar[Any]]):
+        self.thread_local_context = thread_local_context
+
+    def __call__(self, record: "ExtendedRecord"):
+        thread_local_extra = {}
+        for context_var_name, context_var in self.thread_local_context.items():
+            thread_local_extra[context_var_name] = str(context_var.get())
+
+        record["extra"] = flatten_extra(record["extra"])
+        record["extra"] = {**thread_local_extra, **record["extra"]}
+        # Ensure all values are JSON-serializable (e.g., PosixPath -> str)
+        record["extra_json"] = orjson.dumps(record["extra"], default=str).decode()
+
+        record["default_extra"] = {
+            "process_name": record["process"].name,
+            "file_name": record["file"].name,
+            "thread_name": record["thread"].name,
+        }
+        record["default_extra_json"] = orjson.dumps(record["default_extra"], default=str).decode()
+
+        return (
+            "<green>{time:YYYY-MM-DD HH:mm:ss.SSS Z}</green> | "
+            "<level>{level: <8}</level> | "
+            "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - "
+            "<level>{message}</level> - "
+            "<cyan>{extra_json}</cyan> - "
+            "<light-black>{default_extra_json}</light-black>\n"
+        ) + ("\n{exception}\n\n" if record["exception"] else "")
+
+
+class JsonSink(StreamSink):
+    def __init__(
+        self,
+        thread_local_context: dict[str, ContextVar[Any]] | None = None,
+        stream: TextIO | Any = None,
+    ):
+        # sys.stderr is mutable object
+        if stream is None:
+            stream = sys.stderr
+        super().__init__(stream)
+
+        if thread_local_context is None:
+            thread_local_context = {}
+
+        self.thread_local_context = thread_local_context
+
+    def write(self, message: "Message"):
+        record = message.record
+        log_entry = self.json_formatter(record=record)
+        log_message = orjson.dumps(
+            log_entry, default=str, option=orjson.OPT_APPEND_NEWLINE
+        ).decode()
+        return super().write(log_message)
+
+    def json_formatter(self, record: "Record") -> LogType:
+        log_entry: LogType = {
+            LogKey.TIMESTAMP.value: record["time"],
+            LogKey.LEVEL.value: record["level"].name,
+            LogKey.MESSAGE.value: record["message"],
+            LogKey.NAME.value: record["name"],
+            LogKey.PROCESS_NAME.value: record["process"].name,
+            LogKey.FILE_NAME.value: record["file"].name,
+            LogKey.FUNCTION_NAME.value: record["function"],
+            LogKey.LINE_NO.value: record["line"],
+            LogKey.MODULE.value: record["module"],
+            LogKey.THREAD_NAME.value: record["thread"].name,
+        }
+
+        for context_var_name, context_vars in self.thread_local_context.items():
+            log_entry[context_var_name] = str(context_vars.get())
+
+        if record["exception"] is not None:
+            log_entry[LogKey.EXCEPTION.value] = "".join(
+                ExceptionFormatter().format_exception(
+                    type_=record["exception"][0],
+                    value=record["exception"][1],
+                    tb=record["exception"][2],
+                )
+            )
+
+        record["extra"] = flatten_extra(record["extra"])
+        log_entry.update(record["extra"])
+        return log_entry

bake/ui/run/__init__.py

@@ -0,0 +1,11 @@
+"""Subprocess execution utilities for bake UI.
+
+Provides functions for running commands with real-time output streaming
+and capture capabilities.
+"""
+
+from bake.ui.run.run import OutputSplitter, run
+from bake.ui.run.script import run_script
+from bake.ui.run.uv import run_uv
+
+__all__ = ["OutputSplitter", "run", "run_script", "run_uv"]