loopix-sdk 2.30.0__py3-none-any.whl

loopix/template/dockerfile_parser.py

@@ -0,0 +1,286 @@
+import json
+import os
+import re
+import tempfile
+from typing import Dict, List, Optional, Protocol, Union, Literal
+
+from dockerfile_parse import DockerfileParser
+
+
+class DockerfFileFinalParserInterface(Protocol):
+    """Protocol defining the final interface for Dockerfile parsing callbacks."""
+
+
+class DockerfileParserInterface(Protocol):
+    """Protocol defining the interface for Dockerfile parsing callbacks."""
+
+    def run_cmd(
+        self, command: Union[str, List[str]], user: Optional[str] = None
+    ) -> "DockerfileParserInterface":
+        """Handle RUN instruction."""
+        ...
+
+    def copy(
+        self,
+        src: str,
+        dest: str,
+        force_upload: Optional[Literal[True]] = None,
+        user: Optional[str] = None,
+        mode: Optional[int] = None,
+        resolve_symlinks: Optional[bool] = None,
+        gzip: Optional[bool] = None,
+    ) -> "DockerfileParserInterface":
+        """Handle COPY instruction."""
+        ...
+
+    def set_workdir(self, workdir: str) -> "DockerfileParserInterface":
+        """Handle WORKDIR instruction."""
+        ...
+
+    def set_user(self, user: str) -> "DockerfileParserInterface":
+        """Handle USER instruction."""
+        ...
+
+    def set_envs(self, envs: Dict[str, str]) -> "DockerfileParserInterface":
+        """Handle ENV instruction."""
+        ...
+
+    def set_start_cmd(
+        self, start_cmd: str, ready_cmd: str
+    ) -> "DockerfFileFinalParserInterface":
+        """Handle CMD/ENTRYPOINT instruction."""
+        ...
+
+
+def parse_dockerfile(
+    dockerfile_content_or_path: str, template_builder: DockerfileParserInterface
+) -> str:
+    """
+    Parse a Dockerfile and convert it to Template SDK format.
+
+    :param dockerfile_content_or_path: Either the Dockerfile content as a string, or a path to a Dockerfile file
+    :param template_builder: Interface providing template builder methods
+
+    :return: The base image from the Dockerfile
+
+    :raises ValueError: If the Dockerfile is invalid or unsupported
+    """
+    # Check if input is a file path that exists
+    if os.path.isfile(dockerfile_content_or_path):
+        # Read the file content
+        with open(dockerfile_content_or_path, "r", encoding="utf-8") as f:
+            dockerfile_content = f.read()
+    else:
+        # Treat as content directly
+        dockerfile_content = dockerfile_content_or_path
+
+    # Use a temporary directory to avoid creating files in the current directory
+    with tempfile.TemporaryDirectory() as temp_dir:
+        # Create a temporary Dockerfile
+        dockerfile_path = os.path.join(temp_dir, "Dockerfile")
+        with open(dockerfile_path, "w") as f:
+            f.write(dockerfile_content)
+
+        dfp = DockerfileParser(path=temp_dir)
+
+        # Check for multi-stage builds
+        from_instructions = [
+            instruction
+            for instruction in dfp.structure
+            if instruction["instruction"] == "FROM"
+        ]
+
+        if len(from_instructions) > 1:
+            raise ValueError("Multi-stage Dockerfiles are not supported")
+
+        if len(from_instructions) == 0:
+            raise ValueError("Dockerfile must contain a FROM instruction")
+
+        # Set the base image from the first FROM instruction
+        base_image = from_instructions[0]["value"]
+        # Remove AS alias if present (e.g., "node:18 AS builder" -> "node:18")
+        if " as " in base_image.lower():
+            base_image = base_image.split(" as ")[0].strip()
+
+        user_changed = False
+        workdir_changed = False
+
+        # Set the user and workdir to the Docker defaults
+        template_builder.set_user("root")
+        template_builder.set_workdir("/")
+
+        # Process all other instructions
+        for instruction_data in dfp.structure:
+            instruction = instruction_data["instruction"]
+            value = instruction_data["value"]
+
+            if instruction == "FROM":
+                # Already handled above
+                continue
+            elif instruction == "RUN":
+                _handle_run_instruction(value, template_builder)
+            elif instruction in ["COPY", "ADD"]:
+                _handle_copy_instruction(value, template_builder)
+            elif instruction == "WORKDIR":
+                _handle_workdir_instruction(value, template_builder)
+                workdir_changed = True
+            elif instruction == "USER":
+                _handle_user_instruction(value, template_builder)
+                user_changed = True
+            elif instruction in ["ENV", "ARG"]:
+                _handle_env_instruction(value, instruction, template_builder)
+            elif instruction in ["CMD", "ENTRYPOINT"]:
+                _handle_cmd_entrypoint_instruction(value, template_builder)
+            else:
+                print(f"Unsupported instruction: {instruction}")
+                continue
+
+    # Set the user and workdir to the Loopix defaults
+    if not user_changed:
+        template_builder.set_user("user")
+    if not workdir_changed:
+        template_builder.set_workdir("/home/user")
+
+    return base_image
+
+
+def _handle_run_instruction(
+    value: str, template_builder: DockerfileParserInterface
+) -> None:
+    """Handle RUN instruction"""
+    if not value.strip():
+        return
+    # Remove line continuations and normalize whitespace
+    command = re.sub(r"\\\s*\n\s*", " ", value).strip()
+    template_builder.run_cmd(command)
+
+
+def _handle_copy_instruction(
+    value: str, template_builder: DockerfileParserInterface
+) -> None:
+    """Handle COPY/ADD instruction"""
+    if not value.strip():
+        return
+    # Parse source and destination from COPY/ADD command
+    # Handle both quoted and unquoted paths
+    parts = []
+    current_part = ""
+    in_quotes = False
+    quote_char = None
+
+    i = 0
+    while i < len(value):
+        char = value[i]
+        if char in ['"', "'"] and (i == 0 or value[i - 1] != "\\"):
+            if not in_quotes:
+                in_quotes = True
+                quote_char = char
+            elif char == quote_char:
+                in_quotes = False
+                quote_char = None
+            else:
+                current_part += char
+        elif char == " " and not in_quotes:
+            if current_part:
+                parts.append(current_part)
+                current_part = ""
+        else:
+            current_part += char
+        i += 1
+
+    if current_part:
+        parts.append(current_part)
+
+    # Extract --chown flag and separate from paths
+    user = None
+    non_flag_parts = []
+    for part in parts:
+        if part.startswith("--chown="):
+            user = part[8:]  # Extract value after "--chown="
+        elif not part.startswith("--"):
+            non_flag_parts.append(part)
+
+    if len(non_flag_parts) >= 2:
+        dest = non_flag_parts[-1]  # Last part is destination
+        sources = non_flag_parts[:-1]
+
+        for src in sources:
+            template_builder.copy(src, dest, user=user)
+
+
+def _handle_workdir_instruction(
+    value: str, template_builder: DockerfileParserInterface
+) -> None:
+    """Handle WORKDIR instruction"""
+    if not value.strip():
+        return
+    workdir = value.strip()
+    template_builder.set_workdir(workdir)
+
+
+def _handle_user_instruction(
+    value: str, template_builder: DockerfileParserInterface
+) -> None:
+    """Handle USER instruction"""
+    if not value.strip():
+        return
+    user = value.strip()
+    template_builder.set_user(user)
+
+
+def _handle_env_instruction(
+    value: str, instruction_type: str, template_builder: DockerfileParserInterface
+) -> None:
+    """Handle ENV/ARG instruction"""
+    if not value.strip():
+        return
+
+    # Parse environment variables from the value
+    # Handle both "KEY=value" and "KEY value" formats
+    env_vars = {}
+
+    # First try to split on = for KEY=value format
+    if "=" in value:
+        # Handle multiple KEY=value pairs on one line
+        pairs = re.findall(r"(\w+)=([^\s]*(?:\s+(?!\w+=)[^\s]*)*)", value)
+        for key, val in pairs:
+            env_vars[key] = val.strip("\"'")
+    else:
+        # Handle "KEY value" format
+        parts = value.split(None, 1)
+        if len(parts) == 2:
+            key, val = parts
+            env_vars[key] = val.strip("\"'")
+        elif len(parts) == 1 and instruction_type == "ARG":
+            # ARG without default value
+            key = parts[0]
+            env_vars[key] = ""
+
+    # Add each environment variable
+    if env_vars:
+        template_builder.set_envs(env_vars)
+
+
+def _handle_cmd_entrypoint_instruction(
+    value: str, template_builder: DockerfileParserInterface
+) -> None:
+    """Handle CMD/ENTRYPOINT instruction - convert to set_start_cmd with 20s timeout"""
+    if not value.strip():
+        return
+    command = value.strip()
+
+    # Try to parse as JSON (for array format like CMD ["sleep", "infinity"])
+    try:
+        parsed_command = json.loads(command)
+        if isinstance(parsed_command, list):
+            command = " ".join(str(item) for item in parsed_command)
+    except Exception:
+        pass
+
+    # Import wait_for_timeout locally to avoid circular dependency
+    def wait_for_timeout(timeout: int) -> str:
+        # convert to seconds, but ensure minimum of 1 second
+        seconds = max(1, timeout // 1000)
+        return f"sleep {seconds}"
+
+    template_builder.set_start_cmd(command, wait_for_timeout(20_000))

loopix/template/logger.py

@@ -0,0 +1,232 @@
+import sys
+import threading
+import time
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional, TypedDict, Callable, Dict, Literal
+
+from rich.console import Console
+from rich.style import Style
+from rich.text import Text
+
+from loopix.template.utils import strip_ansi_escape_codes
+
+"""Log entry severity levels."""
+LogEntryLevel = Literal["debug", "info", "warn", "error"]
+
+
+@dataclass
+class LogEntry:
+    """
+    Represents a single log entry from the template build process.
+    """
+
+    timestamp: datetime
+    level: LogEntryLevel
+    message: str
+
+    def __post_init__(self):
+        self.message = strip_ansi_escape_codes(self.message)
+
+    def __str__(self) -> str:
+        return f"[{self.timestamp.isoformat()}] [{self.level}] {self.message}"
+
+
+@dataclass
+class LogEntryStart(LogEntry):
+    """
+    Special log entry indicating the start of a build process.
+    """
+
+    level: LogEntryLevel = field(default="debug", init=False)
+
+
+@dataclass
+class LogEntryEnd(LogEntry):
+    """
+    Special log entry indicating the end of a build process.
+    """
+
+    level: LogEntryLevel = field(default="debug", init=False)
+
+
+"""
+Interval in milliseconds for updating the build timer display.
+"""
+TIMER_UPDATE_INTERVAL_MS = 150
+
+"""
+Default minimum log level to display.
+"""
+DEFAULT_LEVEL: LogEntryLevel = "info"
+
+"""
+Colored labels for each log level.
+"""
+levels: Dict[LogEntryLevel, tuple[str, Style]] = {
+    "error": ("ERROR", Style(color="red")),
+    "warn": ("WARN ", Style(color="#FF4400")),
+    "info": ("INFO ", Style(color="#FF8800")),
+    "debug": ("DEBUG", Style(color="bright_black")),
+}
+
+"""
+Numeric ordering of log levels for comparison (lower = less severe).
+"""
+level_order = {
+    "debug": 0,
+    "info": 1,
+    "warn": 2,
+    "error": 3,
+}
+
+
+def set_interval(func, interval):
+    """
+    Returns a stop function that can be called to cancel the interval.
+
+    Similar to JavaScript's setInterval.
+
+    :param func: Function to execute at each interval
+    :param interval: Interval duration in **seconds**
+
+    :return: Stop function that can be called to cancel the interval
+    """
+    stopped = threading.Event()
+
+    def loop():
+        while not stopped.is_set():
+            if stopped.wait(interval):  # wait returns True if stopped
+                break
+            if not stopped.is_set():  # Double-check before executing
+                func()
+
+    threading.Thread(target=loop, daemon=True).start()
+    return stopped.set  # Return the stop function
+
+
+class DefaultBuildLoggerInitialState(TypedDict):
+    start_time: float
+    animation_frame: int
+    timer: Optional[Callable[[], None]]
+
+
+class DefaultBuildLogger:
+    __console = Console()
+
+    __min_level: LogEntryLevel
+    __state: DefaultBuildLoggerInitialState
+
+    def __init__(self, min_level: Optional[LogEntryLevel] = None):
+        self.__min_level = min_level if min_level is not None else DEFAULT_LEVEL
+        self.__reset_initial_state()
+
+    def logger(self, log):
+        if isinstance(log, LogEntryStart):
+            self.__start_timer()
+            return
+
+        if isinstance(log, LogEntryEnd):
+            if self.__state["timer"] is not None:
+                self.__state["timer"]()
+            return
+
+        # Filter by minimum level
+        if level_order[log.level] < level_order[self.__min_level]:
+            return
+
+        formatted_line = self.__format_log_line(log)
+        self.__console.print(formatted_line)
+
+        # Redraw the timer line
+        self.__update_timer()
+
+    def __reset_initial_state(self, timer: Optional[Callable[[], None]] = None):
+        self.__state = {
+            "start_time": time.time(),
+            "animation_frame": 0,
+            "timer": timer,
+        }
+
+    def __format_timer_line(self) -> str:
+        elapsed_seconds = time.time() - self.__state["start_time"]
+        return f"{elapsed_seconds:.1f}s"
+
+    def __animate_status(self) -> str:
+        frames = ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"]
+        idx = self.__state["animation_frame"] % len(frames)
+        return frames[idx]
+
+    def __format_log_line(self, line: LogEntry) -> Text:
+        timer = self.__format_timer_line().ljust(5)
+        timestamp = line.timestamp.strftime("%H:%M:%S")
+        level_text, level_style = levels.get(line.level, levels[DEFAULT_LEVEL])
+
+        # Build a rich Text object
+        text = Text.assemble(
+            timer,
+            " | ",
+            (timestamp, "dim"),
+            " ",
+            (level_text, level_style),
+            " ",
+            line.message,
+        )
+
+        return text
+
+    def __start_timer(self):
+        if not sys.stdout.isatty():
+            return
+
+        # Start the timer interval
+        stop_timer = set_interval(
+            self.__update_timer, TIMER_UPDATE_INTERVAL_MS / 1000.0
+        )
+
+        self.__reset_initial_state(stop_timer)
+
+        # Initial timer display
+        self.__update_timer()
+
+    def __update_timer(self):
+        if not sys.stdout.isatty():
+            return
+
+        self.__state["animation_frame"] += 1
+        jumping_squares = self.__animate_status()
+
+        timer_text = Text.assemble(
+            jumping_squares, " Building ", self.__format_timer_line()
+        )
+
+        # Print with carriage return
+        self.__console.print(timer_text, end="\r")
+
+
+def default_build_logger(
+    min_level: Optional[LogEntryLevel] = None,
+) -> Callable[[LogEntry], None]:
+    """
+    Create a default build logger with animated timer display.
+
+    :param min_level: Minimum log level to display (default: 'info')
+
+    :return: Logger function that accepts LogEntry instances
+
+    Example
+    ```python
+    from loopix import Template, default_build_logger
+
+    template = Template().from_python_image()
+
+    # Use with build - implementation would be in build_async module
+    # await Template.build(template,
+    #     alias='my-template',
+    #     on_build_logs=default_build_logger(min_level='debug')
+    # )
+    ```
+    """
+    build_logger = DefaultBuildLogger(min_level)
+
+    return build_logger.logger