hopx-ai 0.1.10__py3-none-any.whl

hopx_ai/template/builder.py

@@ -0,0 +1,300 @@
+"""
+Template Builder - Fluent API for building templates
+"""
+
+import json
+from pathlib import Path
+from typing import List, Dict, Optional, Union, Any
+from .types import Step, StepType, CopyOptions, ReadyCheck, BuildOptions, BuildResult, RegistryAuth, GCPRegistryAuth, AWSRegistryAuth
+from .build_flow import build_template
+
+
+class Template:
+    """Fluent API for building templates"""
+    
+    def __init__(self):
+        self.steps: List[Step] = []
+        self.start_cmd: Optional[str] = None
+        self.ready_check: Optional[ReadyCheck] = None
+    
+    # ==================== Base Images ====================
+    
+    def from_ubuntu_image(self, version: str) -> 'Template':
+        """Start from Ubuntu base image"""
+        self.steps.append(Step(
+            type=StepType.FROM,
+            args=[f"ubuntu:{version}"]
+        ))
+        return self
+    
+    def from_python_image(self, version: str) -> 'Template':
+        """Start from Python base image"""
+        self.steps.append(Step(
+            type=StepType.FROM,
+            args=[f"python:{version}"]
+        ))
+        return self
+    
+    def from_node_image(self, version: str) -> 'Template':
+        """Start from Node.js base image"""
+        self.steps.append(Step(
+            type=StepType.FROM,
+            args=[f"node:{version}"]
+        ))
+        return self
+    
+    def from_image(self, image: str, auth: Optional[RegistryAuth] = None) -> 'Template':
+        """Start from any Docker image (with optional authentication)"""
+        self.steps.append(Step(
+            type=StepType.FROM,
+            args=[image],
+            registry_auth=auth
+        ))
+        return self
+    
+    def from_gcp_registry(self, image: str, auth: GCPRegistryAuth) -> 'Template':
+        """Start from GCP Container Registry image"""
+        # Parse service account JSON
+        if isinstance(auth.service_account_json, str):
+            # It's a file path
+            with open(auth.service_account_json, 'r') as f:
+                service_account = json.load(f)
+        else:
+            # It's already a dict
+            service_account = auth.service_account_json
+        
+        # GCP uses _json_key as username
+        registry_auth = RegistryAuth(
+            username='_json_key',
+            password=json.dumps(service_account)
+        )
+        
+        return self.from_image(image, registry_auth)
+    
+    def from_aws_registry(self, image: str, auth: AWSRegistryAuth) -> 'Template':
+        """Start from AWS ECR image"""
+        self.steps.append(Step(
+            type=StepType.FROM,
+            args=[image],
+            aws_auth=auth
+        ))
+        return self
+    
+    # ==================== File Operations ====================
+    
+    def copy(
+        self, 
+        src: Union[str, List[str]], 
+        dest: str, 
+        options: Optional[CopyOptions] = None
+    ) -> 'Template':
+        """Copy files to the template"""
+        sources = src if isinstance(src, list) else [src]
+        
+        self.steps.append(Step(
+            type=StepType.COPY,
+            args=[','.join(sources), dest, str(options or {})]
+        ))
+        return self
+    
+    # ==================== Commands ====================
+    
+    def run_cmd(self, cmd: str) -> 'Template':
+        """Run a command during build"""
+        self.steps.append(Step(
+            type=StepType.RUN,
+            args=[cmd]
+        ))
+        return self
+    
+    # ==================== Environment ====================
+    
+    def set_env(self, key: str, value: str) -> 'Template':
+        """Set an environment variable"""
+        self.steps.append(Step(
+            type=StepType.ENV,
+            args=[key, value]
+        ))
+        return self
+    
+    def set_envs(self, vars: Dict[str, str]) -> 'Template':
+        """Set multiple environment variables"""
+        for key, value in vars.items():
+            self.set_env(key, value)
+        return self
+    
+    # ==================== Working Directory ====================
+    
+    def set_workdir(self, directory: str) -> 'Template':
+        """Set working directory"""
+        self.steps.append(Step(
+            type=StepType.WORKDIR,
+            args=[directory]
+        ))
+        return self
+    
+    # ==================== User ====================
+    
+    def set_user(self, user: str) -> 'Template':
+        """Set user"""
+        self.steps.append(Step(
+            type=StepType.USER,
+            args=[user]
+        ))
+        return self
+    
+    # ==================== Smart Helpers ====================
+    
+    def apt_install(self, *packages: Union[str, List[str]]) -> 'Template':
+        """
+        Install packages with apt
+        
+        Examples:
+            .apt_install("curl", "git", "vim")  # Multiple args
+            .apt_install(["curl", "git", "vim"])  # List
+            .apt_install("curl").apt_install("git")  # Chained
+        """
+        # Flatten args
+        pkg_list = []
+        for pkg in packages:
+            if isinstance(pkg, list):
+                pkg_list.extend(pkg)
+            else:
+                pkg_list.append(pkg)
+        
+        if not pkg_list:
+            raise ValueError("apt_install requires at least one package")
+        
+        pkgs = ' '.join(pkg_list)
+        self.run_cmd(
+            f"apt-get update -qq && DEBIAN_FRONTEND=noninteractive apt-get install -y {pkgs}"
+        )
+        return self
+    
+    def pip_install(self, *packages: Union[str, List[str], None]) -> 'Template':
+        """
+        Install Python packages with pip
+        
+        Examples:
+            .pip_install("numpy", "pandas")  # Multiple args
+            .pip_install(["numpy", "pandas"])  # List
+            .pip_install("numpy").pip_install("pandas")  # Chained
+            .pip_install()  # Install from requirements.txt
+        """
+        # Handle no args (requirements.txt)
+        if not packages:
+            self.run_cmd("/usr/local/bin/pip3 install --no-cache-dir -r requirements.txt")
+            return self
+        
+        # Flatten args
+        pkg_list = []
+        for pkg in packages:
+            if pkg is None:
+                continue
+            if isinstance(pkg, list):
+                pkg_list.extend(pkg)
+            else:
+                pkg_list.append(pkg)
+        
+        if not pkg_list:
+            raise ValueError("pip_install requires at least one package or no args for requirements.txt")
+        
+        pkgs = ' '.join(pkg_list)
+        # Use full path for pip (works after systemd restart)
+        self.run_cmd(f"/usr/local/bin/pip3 install --no-cache-dir {pkgs}")
+        return self
+    
+    def npm_install(self, *packages: Union[str, List[str], None]) -> 'Template':
+        """
+        Install Node packages with npm
+        
+        Examples:
+            .npm_install("typescript", "tsx")  # Multiple args
+            .npm_install(["typescript", "tsx"])  # List
+            .npm_install("typescript").npm_install("tsx")  # Chained
+            .npm_install()  # Install from package.json
+        """
+        # Handle no args (package.json)
+        if not packages:
+            self.run_cmd("/usr/bin/npm install")
+            return self
+        
+        # Flatten args
+        pkg_list = []
+        for pkg in packages:
+            if pkg is None:
+                continue
+            if isinstance(pkg, list):
+                pkg_list.extend(pkg)
+            else:
+                pkg_list.append(pkg)
+        
+        if not pkg_list:
+            raise ValueError("npm_install requires at least one package or no args for package.json")
+        
+        pkgs = ' '.join(pkg_list)
+        # Use full path for npm (works after systemd restart)
+        self.run_cmd(f"/usr/bin/npm install -g {pkgs}")
+        return self
+    
+    def go_install(self, packages: List[str]) -> 'Template':
+        """Install Go packages"""
+        for pkg in packages:
+            self.run_cmd(f"go install {pkg}")
+        return self
+    
+    def cargo_install(self, packages: List[str]) -> 'Template':
+        """Install Rust packages with cargo"""
+        for pkg in packages:
+            self.run_cmd(f"cargo install {pkg}")
+        return self
+    
+    def git_clone(self, url: str, dest: str) -> 'Template':
+        """Clone a git repository"""
+        self.run_cmd(f"git clone {url} {dest}")
+        return self
+    
+    # ==================== Caching ====================
+    
+    def skip_cache(self) -> 'Template':
+        """Skip cache for the last step"""
+        if self.steps:
+            self.steps[-1].skip_cache = True
+        return self
+    
+    # ==================== Start Command ====================
+    
+    def set_start_cmd(
+        self, 
+        cmd: str, 
+        ready: Optional[ReadyCheck] = None
+    ) -> 'Template':
+        """Set the start command and ready check"""
+        self.start_cmd = cmd
+        self.ready_check = ready
+        return self
+    
+    # ==================== Build ====================
+    
+    def get_steps(self) -> List[Step]:
+        """Get all steps"""
+        return self.steps
+    
+    def get_start_cmd(self) -> Optional[str]:
+        """Get start command"""
+        return self.start_cmd
+    
+    def get_ready_check(self) -> Optional[ReadyCheck]:
+        """Get ready check"""
+        return self.ready_check
+    
+    @staticmethod
+    async def build(template: 'Template', options: BuildOptions) -> BuildResult:
+        """Build the template"""
+        return await build_template(template, options)
+
+
+def create_template() -> Template:
+    """Factory function to create a new template"""
+    return Template()
+

hopx_ai/template/file_hasher.py

@@ -0,0 +1,81 @@
+"""
+File Hasher - Calculate SHA256 hash for COPY steps
+"""
+
+import hashlib
+import os
+from pathlib import Path
+from typing import List, Tuple
+import glob as glob_module
+
+
+class FileHasher:
+    """Calculate SHA256 hashes for files"""
+    
+    async def calculate_hash(self, src: str, dest: str, context_path: str) -> str:
+        """
+        Calculate SHA256 hash of files and metadata
+        
+        Args:
+            src: Source pattern (e.g., "app/")
+            dest: Destination path (e.g., "/app/")
+            context_path: Base path for resolving src
+            
+        Returns:
+            SHA256 hash string
+        """
+        hasher = hashlib.sha256()
+        
+        # Hash the COPY command
+        hasher.update(f"COPY {src} {dest}".encode('utf-8'))
+        
+        # Get all files matching the pattern
+        pattern = os.path.join(context_path, src)
+        files = glob_module.glob(pattern, recursive=True)
+        
+        # Sort files for consistent hashing
+        files = sorted(files)
+        
+        # Hash each file
+        for file_path in files:
+            if os.path.isfile(file_path):
+                # Relative path from context
+                relative_path = os.path.relpath(file_path, context_path)
+                hasher.update(relative_path.encode('utf-8'))
+                
+                # File stats
+                stat = os.stat(file_path)
+                hasher.update(str(stat.st_mode).encode('utf-8'))
+                hasher.update(str(stat.st_size).encode('utf-8'))
+                hasher.update(str(int(stat.st_mtime * 1000)).encode('utf-8'))
+                
+                # File content
+                with open(file_path, 'rb') as f:
+                    while chunk := f.read(8192):
+                        hasher.update(chunk)
+        
+        return hasher.hexdigest()
+    
+    async def calculate_multi_hash(
+        self, 
+        sources: List[Tuple[str, str]], 
+        context_path: str
+    ) -> str:
+        """
+        Calculate hash for multiple sources
+        
+        Args:
+            sources: List of (src, dest) tuples
+            context_path: Base path
+            
+        Returns:
+            Combined SHA256 hash
+        """
+        hasher = hashlib.sha256()
+        
+        for src, dest in sources:
+            file_hash = await self.calculate_hash(src, dest, context_path)
+            hasher.update(file_hash.encode('utf-8'))
+        
+        return hasher.hexdigest()
+

hopx_ai/template/ready_checks.py

@@ -0,0 +1,106 @@
+"""
+Ready Check Helpers
+"""
+
+from .types import ReadyCheck, ReadyCheckType
+
+
+def wait_for_port(port: int, timeout: int = 30000, interval: int = 2000) -> ReadyCheck:
+    """
+    Wait for TCP port to be open
+    
+    Args:
+        port: Port number to check
+        timeout: Timeout in milliseconds (default: 30000)
+        interval: Check interval in milliseconds (default: 2000)
+        
+    Returns:
+        ReadyCheck configuration
+    """
+    return ReadyCheck(
+        type=ReadyCheckType.PORT,
+        port=port,
+        timeout=timeout,
+        interval=interval,
+    )
+
+
+def wait_for_url(url: str, timeout: int = 30000, interval: int = 2000) -> ReadyCheck:
+    """
+    Wait for HTTP URL to return 200
+    
+    Args:
+        url: URL to check
+        timeout: Timeout in milliseconds (default: 30000)
+        interval: Check interval in milliseconds (default: 2000)
+        
+    Returns:
+        ReadyCheck configuration
+    """
+    return ReadyCheck(
+        type=ReadyCheckType.URL,
+        url=url,
+        timeout=timeout,
+        interval=interval,
+    )
+
+
+def wait_for_file(path: str, timeout: int = 30000, interval: int = 2000) -> ReadyCheck:
+    """
+    Wait for file to exist
+    
+    Args:
+        path: File path to check
+        timeout: Timeout in milliseconds (default: 30000)
+        interval: Check interval in milliseconds (default: 2000)
+        
+    Returns:
+        ReadyCheck configuration
+    """
+    return ReadyCheck(
+        type=ReadyCheckType.FILE,
+        path=path,
+        timeout=timeout,
+        interval=interval,
+    )
+
+
+def wait_for_process(process_name: str, timeout: int = 30000, interval: int = 2000) -> ReadyCheck:
+    """
+    Wait for process to be running
+    
+    Args:
+        process_name: Process name to check
+        timeout: Timeout in milliseconds (default: 30000)
+        interval: Check interval in milliseconds (default: 2000)
+        
+    Returns:
+        ReadyCheck configuration
+    """
+    return ReadyCheck(
+        type=ReadyCheckType.PROCESS,
+        process_name=process_name,
+        timeout=timeout,
+        interval=interval,
+    )
+
+
+def wait_for_command(command: str, timeout: int = 30000, interval: int = 2000) -> ReadyCheck:
+    """
+    Wait for command to exit with code 0
+    
+    Args:
+        command: Command to execute
+        timeout: Timeout in milliseconds (default: 30000)
+        interval: Check interval in milliseconds (default: 2000)
+        
+    Returns:
+        ReadyCheck configuration
+    """
+    return ReadyCheck(
+        type=ReadyCheckType.COMMAND,
+        command=command,
+        timeout=timeout,
+        interval=interval,
+    )
+

hopx_ai/template/tar_creator.py

@@ -0,0 +1,122 @@
+"""
+Tar Creator - Create tar.gz archives
+"""
+
+import os
+import tarfile
+import tempfile
+import glob as glob_module
+from typing import List, BinaryIO
+from dataclasses import dataclass
+
+
+@dataclass
+class TarResult:
+    """Result of tar creation"""
+    file_path: str
+    size: int
+    
+    def open(self, mode: str = 'rb') -> BinaryIO:
+        """Open the tar file"""
+        return open(self.file_path, mode)
+    
+    def cleanup(self):
+        """Delete the temporary file"""
+        if os.path.exists(self.file_path):
+            os.unlink(self.file_path)
+
+
+class TarCreator:
+    """Create tar.gz archives"""
+    
+    async def create_tar_gz(self, src: str, context_path: str) -> TarResult:
+        """
+        Create tar.gz from files
+        
+        Args:
+            src: Source pattern (e.g., "app/")
+            context_path: Base path for resolving src
+            
+        Returns:
+            TarResult with file path and size
+        """
+        # Get all files matching the pattern
+        pattern = os.path.join(context_path, src)
+        files = glob_module.glob(pattern, recursive=True)
+        
+        # Convert to relative paths
+        relative_paths = []
+        for file_path in files:
+            if os.path.exists(file_path):
+                relative_path = os.path.relpath(file_path, context_path)
+                relative_paths.append(relative_path)
+        
+        # Create temporary tar.gz file
+        fd, tmp_file = tempfile.mkstemp(suffix='.tar.gz', prefix='tar-')
+        os.close(fd)
+        
+        try:
+            # Create tar.gz
+            with tarfile.open(tmp_file, 'w:gz') as tar:
+                for relative_path in relative_paths:
+                    full_path = os.path.join(context_path, relative_path)
+                    tar.add(full_path, arcname=relative_path)
+            
+            # Get file size
+            size = os.path.getsize(tmp_file)
+            
+            return TarResult(file_path=tmp_file, size=size)
+        except Exception as e:
+            # Cleanup on error
+            if os.path.exists(tmp_file):
+                os.unlink(tmp_file)
+            raise e
+    
+    async def create_multi_tar_gz(
+        self, 
+        sources: List[str], 
+        context_path: str
+    ) -> TarResult:
+        """
+        Create tar.gz from multiple sources
+        
+        Args:
+            sources: List of source patterns
+            context_path: Base path
+            
+        Returns:
+            TarResult with file path and size
+        """
+        all_files = set()
+        
+        # Collect all files from all sources
+        for src in sources:
+            pattern = os.path.join(context_path, src)
+            files = glob_module.glob(pattern, recursive=True)
+            
+            for file_path in files:
+                if os.path.exists(file_path):
+                    relative_path = os.path.relpath(file_path, context_path)
+                    all_files.add(relative_path)
+        
+        # Create temporary tar.gz file
+        fd, tmp_file = tempfile.mkstemp(suffix='.tar.gz', prefix='tar-')
+        os.close(fd)
+        
+        try:
+            # Create tar.gz
+            with tarfile.open(tmp_file, 'w:gz') as tar:
+                for relative_path in sorted(all_files):
+                    full_path = os.path.join(context_path, relative_path)
+                    tar.add(full_path, arcname=relative_path)
+            
+            # Get file size
+            size = os.path.getsize(tmp_file)
+            
+            return TarResult(file_path=tmp_file, size=size)
+        except Exception as e:
+            # Cleanup on error
+            if os.path.exists(tmp_file):
+                os.unlink(tmp_file)
+            raise e
+