e2b 2.2.0__tar.gz → 2.2.2__tar.gz

{e2b-2.2.0 → e2b-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: e2b
-Version: 2.2.0
+Version: 2.2.2
 Summary: E2B SDK that give agents cloud environments
 Home-page: https://e2b.dev/
 License: MIT

{e2b-2.2.0 → e2b-2.2.2}/e2b/__init__.py

@@ -71,6 +71,8 @@ from .sandbox_sync.paginator import SandboxPaginator
 
 from .template.main import TemplateBase, TemplateClass
 
+from .template.types import CopyItem
+
 from .template_sync.main import Template
 from .template_async.main import AsyncTemplate
 
@@ -136,6 +138,7 @@ __all__ = [
     "AsyncTemplate",
     "TemplateBase",
     "TemplateClass",
+    "CopyItem",
     "wait_for_file",
     "wait_for_url",
     "wait_for_port",

{e2b-2.2.0 → e2b-2.2.2}/e2b/template/consts.py

@@ -7,3 +7,5 @@ Depths explained:
 2. Caller method (eg. copy(), fromImage(), etc.)
 """
 STACK_TRACE_DEPTH = 2
+
+RESOLVE_SYMLINKS = False

{e2b-2.2.0 → e2b-2.2.2}/e2b/template/dockerfile_parser.py

@@ -1,7 +1,7 @@
 import os
 import re
 import tempfile
-from typing import Dict, List, Optional, Protocol, Union
+from typing import Dict, List, Optional, Protocol, Union, Literal
 
 from dockerfile_parse import DockerfileParser
 from e2b.template.types import CopyItem
@@ -24,7 +24,8 @@ class DockerfileParserInterface(Protocol):
         self,
         src: Union[str, List[CopyItem]],
         dest: Optional[str] = None,
-        force_upload: Optional[bool] = None,
+        force_upload: Optional[Literal[True]] = None,
+        resolve_symlinks: Optional[bool] = None,
         user: Optional[str] = None,
         mode: Optional[int] = None,
     ) -> "DockerfileParserInterface":
@@ -239,7 +240,7 @@ def _handle_env_instruction(
 def _handle_cmd_entrypoint_instruction(
     value: str, template_builder: DockerfileParserInterface
 ) -> None:
-    """Handle CMD/ENTRYPOINT instruction - convert to setStartCmd with 20s timeout"""
+    """Handle CMD/ENTRYPOINT instruction - convert to set_start_cmd with 20s timeout"""
     if not value.strip():
         return
     command = value.strip()

{e2b-2.2.0 → e2b-2.2.2}/e2b/template/main.py

@@ -1,10 +1,12 @@
 import json
-from typing import Dict, List, Optional, Union
-from types import TracebackType
+from typing import Dict, List, Optional, Union, Literal
+from pathlib import Path
+
 from httpx import Limits
 
-from e2b.template.consts import STACK_TRACE_DEPTH
+from e2b.template.consts import STACK_TRACE_DEPTH, RESOLVE_SYMLINKS
 from e2b.template.dockerfile_parser import parse_dockerfile
+from e2b.template.readycmd import ReadyCmd
 from e2b.template.types import (
     CopyItem,
     Instruction,
@@ -20,7 +22,7 @@ from e2b.template.utils import (
     read_gcp_service_account_json,
     get_caller_frame,
 )
-from e2b.template.readycmd import ReadyCmd
+from types import TracebackType
 
 
 class TemplateBuilder:
@@ -29,62 +31,74 @@ class TemplateBuilder:
 
     def copy(
         self,
-        src: Union[str, List[CopyItem]],
-        dest: Optional[str] = None,
-        force_upload: Optional[bool] = None,
+        src: Union[Union[str, Path], List[Union[str, Path]]],
+        dest: Union[str, Path],
+        force_upload: Optional[Literal[True]] = None,
         user: Optional[str] = None,
         mode: Optional[int] = None,
+        resolve_symlinks: Optional[bool] = None,
     ) -> "TemplateBuilder":
-        if isinstance(src, str):
-            # Single copy operation
-            if dest is None:
-                raise ValueError("dest parameter is required when src is a string")
-            copy_items: List[CopyItem] = [
-                {
-                    "src": src,
-                    "dest": dest,
-                    "forceUpload": force_upload,
-                    "user": user,
-                    "mode": mode,
-                }
-            ]
-        else:
-            # Multiple copy operations
-            copy_items = src
+        srcs = [src] if isinstance(src, (str, Path)) else src
 
-        for copy_item in copy_items:
+        for src_item in srcs:
             args = [
-                copy_item["src"],
-                copy_item["dest"],
+                str(src_item),
+                str(dest),
                 user or "",
                 pad_octal(mode) if mode else "",
             ]
 
-            instruction: Instruction = Instruction(
-                type=InstructionType.COPY,
-                args=args,
-                force=force_upload or self._template._force_next_layer,
-                forceUpload=force_upload,
-            )
+            instruction: Instruction = {
+                "type": InstructionType.COPY,
+                "args": args,
+                "force": force_upload or self._template._force_next_layer,
+                "forceUpload": force_upload,
+                "resolveSymlinks": resolve_symlinks,
+            }
+
             self._template._instructions.append(instruction)
+
         self._template._collect_stack_trace()
         return self
 
+    def copy_items(self, items: List[CopyItem]) -> "TemplateBuilder":
+        self._template._run_in_new_stack_trace_context(
+            lambda: [
+                self.copy(
+                    item["src"],
+                    item["dest"],
+                    item.get("forceUpload"),
+                    item.get("user"),
+                    item.get("mode"),
+                    item.get("resolveSymlinks"),
+                )
+                for item in items
+            ]
+        )
+        return self
+
     def remove(
-        self, path: str, force: bool = False, recursive: bool = False
+        self,
+        path: Union[Union[str, Path], List[Union[str, Path]]],
+        force: bool = False,
+        recursive: bool = False,
     ) -> "TemplateBuilder":
-        args = ["rm", path]
+        paths = [path] if isinstance(path, (str, Path)) else path
+        args = ["rm"]
         if recursive:
             args.append("-r")
         if force:
             args.append("-f")
+        args.extend([str(p) for p in paths])
 
         return self._template._run_in_new_stack_trace_context(
             lambda: self.run_cmd(" ".join(args))
         )
 
-    def rename(self, src: str, dest: str, force: bool = False) -> "TemplateBuilder":
-        args = ["mv", src, dest]
+    def rename(
+        self, src: Union[str, Path], dest: Union[str, Path], force: bool = False
+    ) -> "TemplateBuilder":
+        args = ["mv", str(src), str(dest)]
         if force:
             args.append("-f")
 
@@ -93,21 +107,24 @@ class TemplateBuilder:
         )
 
     def make_dir(
-        self, paths: Union[str, List[str]], mode: Optional[int] = None
+        self,
+        path: Union[Union[str, Path], List[Union[str, Path]]],
+        mode: Optional[int] = None,
     ) -> "TemplateBuilder":
-        if isinstance(paths, str):
-            paths = [paths]
-
-        args = ["mkdir", "-p", *paths]
+        path_list = [path] if isinstance(path, (str, Path)) else path
+        args = ["mkdir", "-p"]
         if mode:
             args.append(f"-m {pad_octal(mode)}")
+        args.extend([str(p) for p in path_list])
 
         return self._template._run_in_new_stack_trace_context(
             lambda: self.run_cmd(" ".join(args))
         )
 
-    def make_symlink(self, src: str, dest: str) -> "TemplateBuilder":
-        args = ["ln", "-s", src, dest]
+    def make_symlink(
+        self, src: Union[str, Path], dest: Union[str, Path]
+    ) -> "TemplateBuilder":
+        args = ["ln", "-s", str(src), str(dest)]
         return self._template._run_in_new_stack_trace_context(
             lambda: self.run_cmd(" ".join(args))
         )
@@ -121,34 +138,34 @@ class TemplateBuilder:
         if user:
             args.append(user)
 
-        instruction: Instruction = Instruction(
-            type=InstructionType.RUN,
-            args=args,
-            force=self._template._force_next_layer,
-            forceUpload=None,
-        )
+        instruction: Instruction = {
+            "type": InstructionType.RUN,
+            "args": args,
+            "force": self._template._force_next_layer,
+            "forceUpload": None,
+        }
         self._template._instructions.append(instruction)
         self._template._collect_stack_trace()
         return self
 
-    def set_workdir(self, workdir: str) -> "TemplateBuilder":
-        instruction: Instruction = Instruction(
-            type=InstructionType.WORKDIR,
-            args=[workdir],
-            force=self._template._force_next_layer,
-            forceUpload=None,
-        )
+    def set_workdir(self, workdir: Union[str, Path]) -> "TemplateBuilder":
+        instruction: Instruction = {
+            "type": InstructionType.WORKDIR,
+            "args": [str(workdir)],
+            "force": self._template._force_next_layer,
+            "forceUpload": None,
+        }
         self._template._instructions.append(instruction)
         self._template._collect_stack_trace()
         return self
 
     def set_user(self, user: str) -> "TemplateBuilder":
-        instruction: Instruction = Instruction(
-            type=InstructionType.USER,
-            args=[user],
-            force=self._template._force_next_layer,
-            forceUpload=None,
-        )
+        instruction: Instruction = {
+            "type": InstructionType.USER,
+            "args": [user],
+            "force": self._template._force_next_layer,
+            "forceUpload": None,
+        }
         self._template._instructions.append(instruction)
         self._template._collect_stack_trace()
         return self
@@ -204,18 +221,18 @@ class TemplateBuilder:
     def git_clone(
         self,
         url: str,
-        path: Optional[str] = None,
+        path: Optional[Union[str, Path]] = None,
         branch: Optional[str] = None,
         depth: Optional[int] = None,
     ) -> "TemplateBuilder":
         args = ["git", "clone", url]
-        if path:
-            args.append(path)
         if branch:
             args.append(f"--branch {branch}")
             args.append("--single-branch")
         if depth:
             args.append(f"--depth {depth}")
+        if path:
+            args.append(str(path))
         return self._template._run_in_new_stack_trace_context(
             lambda: self.run_cmd(" ".join(args))
         )
@@ -224,12 +241,12 @@ class TemplateBuilder:
         if len(envs) == 0:
             return self
 
-        instruction: Instruction = Instruction(
-            type=InstructionType.ENV,
-            args=[item for key, value in envs.items() for item in [key, value]],
-            force=self._template._force_next_layer,
-            forceUpload=None,
-        )
+        instruction: Instruction = {
+            "type": InstructionType.ENV,
+            "args": [item for key, value in envs.items() for item in [key, value]],
+            "force": self._template._force_next_layer,
+            "forceUpload": None,
+        }
         self._template._instructions.append(instruction)
         self._template._collect_stack_trace()
         return self
@@ -274,8 +291,8 @@ class TemplateBase:
 
     def __init__(
         self,
-        file_context_path: Optional[str] = None,
-        ignore_file_paths: Optional[List[str]] = None,
+        file_context_path: Optional[Union[str, Path]] = None,
+        file_ignore_patterns: Optional[List[str]] = None,
     ):
         self._default_base_image: str = "e2bdev/base"
         self._base_image: Optional[str] = self._default_base_image
@@ -289,11 +306,13 @@ class TemplateBase:
         self._force_next_layer: bool = False
         self._instructions: List[Instruction] = []
         # If no file_context_path is provided, use the caller's directory
-        self._file_context_path: str = (
-            file_context_path or get_caller_directory(STACK_TRACE_DEPTH) or "."
+        self._file_context_path = (
+            file_context_path.as_posix()
+            if isinstance(file_context_path, Path)
+            else (file_context_path or get_caller_directory(STACK_TRACE_DEPTH) or ".")
         )
-        self._ignore_file_paths: List[str] = ignore_file_paths or []
-        self._stack_traces: List[TracebackType] = []
+        self._file_ignore_patterns: List[str] = file_ignore_patterns or []
+        self._stack_traces: List[Union[TracebackType, None]] = []
         self._stack_traces_enabled: bool = True
 
     def skip_cache(self) -> "TemplateBase":
@@ -302,7 +321,7 @@ class TemplateBase:
         return self
 
     def _collect_stack_trace(
-        self, stack_traces_depth: Optional[int] = STACK_TRACE_DEPTH
+        self, stack_traces_depth: int = STACK_TRACE_DEPTH
     ) -> "TemplateBase":
         """Collect stack trace if enabled"""
         if not self._stack_traces_enabled:
@@ -369,15 +388,22 @@ class TemplateBase:
         )
 
     def from_image(
-        self, base_image: str, registry_config: Optional[RegistryConfig] = None
+        self,
+        image: str,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
     ) -> TemplateBuilder:
         """Private method to set base image without adding stack trace"""
-        self._base_image = base_image
+        self._base_image = image
         self._base_template = None
 
         # Set the registry config if provided
-        if registry_config is not None:
-            self._registry_config = registry_config
+        if username and password:
+            self._registry_config = {
+                "type": "registry",
+                "username": username,
+                "password": password,
+            }
 
         # If we should force the next layer and it's a FROM command, invalidate whole template
         if self._force_next_layer:
@@ -418,20 +444,6 @@ class TemplateBase:
         self._collect_stack_trace()
         return builder
 
-    def from_registry(
-        self, image: str, username: str, password: str
-    ) -> TemplateBuilder:
-        return self._run_in_new_stack_trace_context(
-            lambda: self.from_image(
-                image,
-                registry_config={
-                    "type": "registry",
-                    "username": username,
-                    "password": password,
-                },
-            )
-        )
-
     def from_aws_registry(
         self,
         image: str,
@@ -439,32 +451,44 @@ class TemplateBase:
         secret_access_key: str,
         region: str,
     ) -> TemplateBuilder:
-        return self._run_in_new_stack_trace_context(
-            lambda: self.from_image(
-                image,
-                registry_config={
-                    "type": "aws",
-                    "awsAccessKeyId": access_key_id,
-                    "awsSecretAccessKey": secret_access_key,
-                    "awsRegion": region,
-                },
-            )
-        )
+        self._base_image = image
+        self._base_template = None
+
+        # Set the registry config if provided
+        self._registry_config = {
+            "type": "aws",
+            "awsAccessKeyId": access_key_id,
+            "awsSecretAccessKey": secret_access_key,
+            "awsRegion": region,
+        }
+
+        # If we should force the next layer and it's a FROM command, invalidate whole template
+        if self._force_next_layer:
+            self._force = True
+
+        self._collect_stack_trace()
+        return TemplateBuilder(self)
 
     def from_gcp_registry(
         self, image: str, service_account_json: Union[str, dict]
     ) -> TemplateBuilder:
-        return self._run_in_new_stack_trace_context(
-            lambda: self.from_image(
-                image,
-                registry_config={
-                    "type": "gcp",
-                    "serviceAccountJson": read_gcp_service_account_json(
-                        self._file_context_path, service_account_json
-                    ),
-                },
-            )
-        )
+        self._base_image = image
+        self._base_template = None
+
+        # Set the registry config if provided
+        self._registry_config = {
+            "type": "gcp",
+            "serviceAccountJson": read_gcp_service_account_json(
+                self._file_context_path, service_account_json
+            ),
+        }
+
+        # If we should force the next layer and it's a FROM command, invalidate whole template
+        if self._force_next_layer:
+            self._force = True
+
+        self._collect_stack_trace()
+        return TemplateBuilder(self)
 
     @staticmethod
     def to_json(template: "TemplateClass") -> str:
@@ -504,12 +528,13 @@ class TemplateBase:
         steps: List[Instruction] = []
 
         for index, instruction in enumerate(self._instructions):
-            step: Instruction = Instruction(
-                type=instruction["type"].value,
-                args=instruction["args"],
-                force=instruction["force"],
-                forceUpload=instruction.get("forceUpload"),
-            )
+            step: Instruction = {
+                "type": instruction["type"],
+                "args": instruction["args"],
+                "force": instruction["force"],
+                "forceUpload": instruction.get("forceUpload"),
+                "resolveSymlinks": instruction.get("resolveSymlinks"),
+            }
 
             if instruction["type"] == InstructionType.COPY:
                 stack_trace = None
@@ -527,9 +552,10 @@ class TemplateBase:
                     dest,
                     self._file_context_path,
                     [
-                        *self._ignore_file_paths,
+                        *self._file_ignore_patterns,
                         *read_dockerignore(self._file_context_path),
                     ],
+                    instruction.get("resolveSymlinks", RESOLVE_SYMLINKS),
                     stack_trace,
                 )
 
@@ -538,8 +564,25 @@ class TemplateBase:
         return steps
 
     def _serialize(self, steps: List[Instruction]) -> TemplateType:
+        _steps: List[Instruction] = []
+
+        for _, instruction in enumerate(steps):
+            step: Instruction = {
+                "type": instruction.get("type"),
+                "args": instruction.get("args"),
+                "force": instruction.get("force"),
+            }
+
+            if instruction.get("filesHash") is not None:
+                step["filesHash"] = instruction["filesHash"]
+
+            if instruction.get("forceUpload") is not None:
+                step["forceUpload"] = instruction["forceUpload"]
+
+            _steps.append(step)
+
         template_data: TemplateType = {
-            "steps": steps,
+            "steps": _steps,
             "force": self._force,
         }
 

{e2b-2.2.0 → e2b-2.2.2}/e2b/template/types.py

@@ -4,10 +4,11 @@ from dataclasses import dataclass
 from datetime import datetime
 from typing import Literal
 from enum import Enum
+from pathlib import Path
 from e2b.template.utils import strip_ansi_escape_codes
 
 
-class InstructionType(Enum):
+class InstructionType(str, Enum):
     COPY = "COPY"
     ENV = "ENV"
     RUN = "RUN"
@@ -16,19 +17,21 @@ class InstructionType(Enum):
 
 
 class CopyItem(TypedDict):
-    src: str
-    dest: str
-    forceUpload: NotRequired[Optional[bool]]
+    src: Union[Union[str, Path], List[Union[str, Path]]]
+    dest: Union[str, Path]
+    forceUpload: NotRequired[Optional[Literal[True]]]
     user: NotRequired[Optional[str]]
     mode: NotRequired[Optional[int]]
+    resolveSymlinks: NotRequired[Optional[bool]]
 
 
 class Instruction(TypedDict):
     type: InstructionType
     args: List[str]
     force: bool
-    forceUpload: NotRequired[Optional[bool]]
+    forceUpload: NotRequired[Optional[Literal[True]]]
     filesHash: NotRequired[Optional[str]]
+    resolveSymlinks: NotRequired[Optional[bool]]
 
 
 @dataclass

{e2b-2.2.0 → e2b-2.2.2}/e2b/template/utils.py

@@ -1,6 +1,7 @@
 import hashlib
 import os
 import json
+import stat
 from glob import glob
 import fnmatch
 import re
@@ -30,8 +31,9 @@ def calculate_files_hash(
     src: str,
     dest: str,
     context_path: str,
-    ignore_patterns: Optional[List[str]] = None,
-    stack_trace: Optional[TracebackType] = None,
+    ignore_patterns: List[str],
+    resolve_symlinks: bool,
+    stack_trace: Optional[TracebackType],
 ) -> str:
     src_path = os.path.join(context_path, src)
     hash_obj = hashlib.sha256()
@@ -52,12 +54,38 @@ def calculate_files_hash(
     if len(files) == 0:
         raise ValueError(f"No files found in {src_path}").with_traceback(stack_trace)
 
+    def hash_stats(stat_info: os.stat_result) -> None:
+        hash_obj.update(str(stat_info.st_mode).encode())
+        hash_obj.update(str(stat_info.st_uid).encode())
+        hash_obj.update(str(stat_info.st_gid).encode())
+        hash_obj.update(str(stat_info.st_size).encode())
+        hash_obj.update(str(stat_info.st_mtime).encode())
+
     for file in files:
-        if not os.path.isfile(file):
-            # skip folders
-            continue
-        with open(file, "rb") as f:
-            hash_obj.update(f.read())
+        # Add a relative path to hash calculation
+        relative_path = os.path.relpath(file, context_path)
+        hash_obj.update(relative_path.encode())
+
+        # Add stat information to hash calculation
+        if os.path.islink(file):
+            stats = os.lstat(file)
+            should_follow = resolve_symlinks and (
+                os.path.isfile(file) or os.path.isdir(file)
+            )
+
+            if not should_follow:
+                hash_stats(stats)
+
+                content = os.readlink(file)
+                hash_obj.update(content.encode())
+                continue
+
+        stats = os.stat(file)
+        hash_stats(stats)
+
+        if stat.S_ISREG(stats.st_mode):
+            with open(file, "rb") as f:
+                hash_obj.update(f.read())
 
     return hash_obj.hexdigest()