loopix-sdk 2.30.0__py3-none-any.whl

loopix/sandbox/_git/parse.py

@@ -0,0 +1,222 @@
+from typing import List, Optional
+from urllib.parse import urlparse
+
+from loopix.exceptions import InvalidArgumentException
+from loopix.sandbox._git.types import GitBranches, GitFileStatus, GitStatus
+
+
+def derive_repo_dir_from_url(url: str) -> Optional[str]:
+    """
+    Derive the default repository directory name from a Git URL.
+
+    :param url: Git repository URL
+    :return: Repository directory name, if it can be determined
+    """
+    parsed = urlparse(url)
+    if parsed.scheme not in ("http", "https"):
+        return None
+    trimmed_path = parsed.path.rstrip("/")
+    if not trimmed_path:
+        return None
+    last_segment = trimmed_path.split("/")[-1]
+    if not last_segment:
+        return None
+    return last_segment[:-4] if last_segment.endswith(".git") else last_segment
+
+
+def _parse_ahead_behind(segment: Optional[str]) -> tuple[int, int]:
+    """
+    Parse the ahead/behind segment from porcelain branch info.
+
+    :param segment: Segment text like "ahead 2, behind 1"
+    :return: Tuple of (ahead, behind)
+    """
+    if not segment:
+        return 0, 0
+    ahead = 0
+    behind = 0
+    if "ahead" in segment:
+        try:
+            ahead = int(segment.split("ahead")[1].split(",")[0].strip())
+        except Exception:
+            ahead = 0
+    if "behind" in segment:
+        try:
+            behind = int(segment.split("behind")[1].split(",")[0].strip())
+        except Exception:
+            behind = 0
+    return ahead, behind
+
+
+def _normalize_branch_name(name: str) -> str:
+    """
+    Normalize branch names from porcelain branch output.
+
+    :param name: Raw branch name section
+    :return: Normalized branch name
+    """
+    if name.startswith("HEAD (detached at "):
+        return name.replace("HEAD (detached at ", "").rstrip(")")
+    return (
+        name.replace("HEAD (no branch)", "HEAD")
+        .replace("No commits yet on ", "")
+        .replace("Initial commit on ", "")
+    )
+
+
+def _derive_status(index_status: str, working_status: str) -> str:
+    """
+    Derive a normalized status label from porcelain status characters.
+
+    :param index_status: Index status character
+    :param working_status: Working tree status character
+    :return: Normalized status label
+    """
+    statuses = {index_status, working_status}
+    if "U" in statuses:
+        return "conflict"
+    if "R" in statuses:
+        return "renamed"
+    if "C" in statuses:
+        return "copied"
+    if "D" in statuses:
+        return "deleted"
+    if "A" in statuses:
+        return "added"
+    if "M" in statuses:
+        return "modified"
+    if "T" in statuses:
+        return "typechange"
+    if "?" in statuses:
+        return "untracked"
+    return "unknown"
+
+
+def parse_git_status(output: str) -> GitStatus:
+    """
+    Parse `git status --porcelain=1 -b` output into a structured object.
+
+    :param output: Git status output
+    :return: Parsed `GitStatus`
+    """
+    lines = [line.rstrip() for line in output.split("\n") if line.strip()]
+    current_branch: Optional[str] = None
+    upstream: Optional[str] = None
+    ahead = 0
+    behind = 0
+    detached = False
+    file_status: List[GitFileStatus] = []
+
+    if not lines:
+        return GitStatus(
+            current_branch=current_branch,
+            upstream=upstream,
+            ahead=ahead,
+            behind=behind,
+            detached=detached,
+            file_status=file_status,
+        )
+
+    branch_line = lines[0]
+    if branch_line.startswith("## "):
+        branch_info = branch_line[3:]
+        ahead_start = branch_info.find(" [")
+        branch_part = branch_info if ahead_start == -1 else branch_info[:ahead_start]
+        ahead_part = None if ahead_start == -1 else branch_info[ahead_start + 2 : -1]
+        normalized_branch = _normalize_branch_name(branch_part)
+        raw_branch = branch_part
+        is_detached = raw_branch.startswith("HEAD (detached at ") or (
+            "detached" in raw_branch
+        )
+
+        if is_detached or normalized_branch.startswith("HEAD"):
+            detached = True
+        elif "..." in normalized_branch:
+            branch, upstream_branch = normalized_branch.split("...")
+            current_branch = branch or None
+            upstream = upstream_branch or None
+        else:
+            current_branch = normalized_branch or None
+
+        ahead, behind = _parse_ahead_behind(ahead_part)
+
+    for line in lines[1:]:
+        if line.startswith("?? "):
+            name = line[3:]
+            file_status.append(
+                GitFileStatus(
+                    name=name,
+                    status="untracked",
+                    index_status="?",
+                    working_tree_status="?",
+                    staged=False,
+                )
+            )
+            continue
+
+        if len(line) < 3:
+            continue
+        index_status = line[0]
+        working_status = line[1]
+        path = line[3:]
+        renamed_from: Optional[str] = None
+        name = path
+        if " -> " in path:
+            renamed_from, name = path.split(" -> ", 1)
+
+        file_status.append(
+            GitFileStatus(
+                name=name,
+                status=_derive_status(index_status, working_status),
+                index_status=index_status,
+                working_tree_status=working_status,
+                staged=index_status not in (" ", "?"),
+                renamed_from=renamed_from,
+            )
+        )
+
+    return GitStatus(
+        current_branch=current_branch,
+        upstream=upstream,
+        ahead=ahead,
+        behind=behind,
+        detached=detached,
+        file_status=file_status,
+    )
+
+
+def parse_git_branches(output: str) -> GitBranches:
+    """
+    Parse `git branch --format=%(refname:short)\t%(HEAD)` output.
+
+    :param output: Git branch output
+    :return: Parsed `GitBranches`
+    """
+    branches: List[str] = []
+    current_branch: Optional[str] = None
+
+    lines = [line.strip() for line in output.split("\n") if line.strip()]
+    for line in lines:
+        parts = line.split("\t")
+        name = parts[0]
+        branches.append(name)
+        if len(parts) > 1 and parts[1] == "*":
+            current_branch = name
+
+    return GitBranches(branches=branches, current_branch=current_branch)
+
+
+def parse_remote_url(output: str, remote: str) -> str:
+    """
+    Parse a git remote URL output and validate it's present.
+
+    :param output: Git remote get-url output
+    :param remote: Remote name for the error message
+    :return: Remote URL
+    """
+    url = output.strip()
+    if not url:
+        raise InvalidArgumentException(
+            f'Remote "{remote}" URL not found in repository.'
+        )
+    return url

loopix/sandbox/_git/types.py

@@ -0,0 +1,149 @@
+from dataclasses import dataclass
+from typing import List, Optional
+
+from typing_extensions import Literal
+
+GitResetMode = Literal["soft", "mixed", "hard", "merge", "keep"]
+"""Mode for a git reset operation."""
+
+
+@dataclass
+class GitFileStatus:
+    """
+    Parsed git status entry for a file.
+
+    :param name: Path relative to the repository root
+    :param status: Normalized status string (e.g. "modified", "added")
+    :param index_status: Index status character from porcelain output
+    :param working_tree_status: Working tree status character from porcelain output
+    :param staged: Whether the change is staged
+    :param renamed_from: Original path when the file was renamed
+    """
+
+    name: str
+    status: str
+    index_status: str
+    working_tree_status: str
+    staged: bool
+    renamed_from: Optional[str] = None
+
+
+@dataclass
+class GitStatus:
+    """
+    Parsed git repository status.
+
+    :param current_branch: Current branch name, if available
+    :param upstream: Upstream branch name, if available
+    :param ahead: Number of commits the branch is ahead of upstream
+    :param behind: Number of commits the branch is behind upstream
+    :param detached: Whether HEAD is detached
+    :param file_status: List of file status entries
+    """
+
+    current_branch: Optional[str]
+    upstream: Optional[str]
+    ahead: int
+    behind: int
+    detached: bool
+    file_status: List[GitFileStatus]
+
+    @property
+    def is_clean(self) -> bool:
+        """
+        Return True when there are no tracked or untracked file changes.
+        """
+        return len(self.file_status) == 0
+
+    @property
+    def has_changes(self) -> bool:
+        """
+        Return True when there are any tracked or untracked file changes.
+        """
+        return len(self.file_status) > 0
+
+    @property
+    def has_staged(self) -> bool:
+        """
+        Return True when at least one file has staged changes.
+        """
+        return any(item.staged for item in self.file_status)
+
+    @property
+    def has_untracked(self) -> bool:
+        """
+        Return True when at least one file is untracked.
+        """
+        return any(item.status == "untracked" for item in self.file_status)
+
+    @property
+    def has_conflicts(self) -> bool:
+        """
+        Return True when at least one file is in conflict.
+        """
+        return any(item.status == "conflict" for item in self.file_status)
+
+    @property
+    def total_count(self) -> int:
+        """
+        Return the total number of changed files.
+        """
+        return len(self.file_status)
+
+    @property
+    def staged_count(self) -> int:
+        """
+        Return the number of files with staged changes.
+        """
+        return sum(1 for item in self.file_status if item.staged)
+
+    @property
+    def unstaged_count(self) -> int:
+        """
+        Return the number of files with unstaged changes.
+        """
+        return sum(1 for item in self.file_status if not item.staged)
+
+    @property
+    def untracked_count(self) -> int:
+        """
+        Return the number of untracked files.
+        """
+        return sum(1 for item in self.file_status if item.status == "untracked")
+
+    @property
+    def conflict_count(self) -> int:
+        """
+        Return the number of files with merge conflicts.
+        """
+        return sum(1 for item in self.file_status if item.status == "conflict")
+
+
+@dataclass
+class GitBranches:
+    """
+    Parsed git branch list.
+
+    :param branches: List of branch names
+    :param current_branch: Current branch name, if available
+    """
+
+    branches: List[str]
+    current_branch: Optional[str]
+
+
+@dataclass
+class ClonePlan:
+    """
+    Prepared arguments and metadata for git clone.
+
+    :param args: Command arguments for git clone
+    :param repo_path: Repository path to use for post-clone adjustments
+    :param sanitized_url: Credential-stripped URL to restore
+    :param should_strip: Whether to reset the remote URL after clone
+    """
+
+    args: List[str]
+    repo_path: Optional[str]
+    sanitized_url: Optional[str]
+    should_strip: bool

loopix/sandbox/commands/command_handle.py

@@ -0,0 +1,69 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from loopix.exceptions import SandboxException
+
+Stdout = str
+"""
+Command stdout output.
+"""
+Stderr = str
+"""
+Command stderr output.
+"""
+PtyOutput = bytes
+"""
+Pty output.
+"""
+
+
+@dataclass
+class PtySize:
+    """
+    Pseudo-terminal size.
+    """
+
+    rows: int
+    """
+    Number of rows.
+    """
+    cols: int
+    """
+    Number of columns.
+    """
+
+
+@dataclass
+class CommandResult:
+    """
+    Command execution result.
+    """
+
+    stderr: str
+    """
+    Command stderr output.
+    """
+    stdout: str
+    """
+    Command stdout output.
+    """
+    exit_code: int
+    """
+    Command exit code.
+
+    `0` if the command finished successfully.
+    """
+    error: Optional[str]
+    """
+    Error message from command execution if it failed.
+    """
+
+
+@dataclass
+class CommandExitException(SandboxException, CommandResult):
+    """
+    Exception raised when a command exits with a non-zero exit code.
+    """
+
+    def __str__(self):
+        return f"Command exited with code {self.exit_code} and error:\n{self.stderr}"

loopix/sandbox/commands/main.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+
+@dataclass
+class ProcessInfo:
+    """
+    Information about a command, PTY session or start command running in the sandbox as process.
+    """
+
+    pid: int
+    """
+    Process ID.
+    """
+
+    tag: Optional[str]
+    """
+    Custom tag used for identifying special commands like start command in the custom template.
+    """
+
+    cmd: str
+    """
+    Command that was executed.
+    """
+
+    args: List[str]
+    """
+    Command arguments.
+    """
+
+    envs: Dict[str, str]
+    """
+    Environment variables used for the command.
+    """
+
+    cwd: Optional[str]
+    """
+    Executed command working directory.
+    """