agentscope-runtime 1.0.0b2__py3-none-any.whl → 1.0.2__py3-none-any.whl

agentscope_runtime/engine/deployers/utils/detached_app.py

@@ -1,12 +1,13 @@
 # -*- coding: utf-8 -*-
-# pylint:disable=too-many-return-statements
+# pylint:disable=too-many-return-statements, too-many-branches
 
 """Shared helpers for building detached deployment bundles."""
 
 from __future__ import annotations
-import os
 
 import json
+import os
+import re
 import shutil
 import tempfile
 import zipfile
@@ -14,10 +15,14 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Type, Union
 
 from .app_runner_utils import ensure_runner_from_app
-from .package import package, ProjectInfo, DEFAULT_ENTRYPOINT_FILE
+from .package import (
+    package,
+    ProjectInfo,
+    DEFAULT_ENTRYPOINT_FILE,
+    DEPLOYMENT_ZIP,
+    generate_build_directory,
+)
 from ..adapter.protocol_adapter import ProtocolAdapter
-from .package import DEPLOYMENT_ZIP
-from .wheel_packager import _parse_pyproject_toml
 
 try:
     import tomllib  # Python 3.11+
@@ -36,19 +41,25 @@ def build_detached_app(
     *,
     app=None,
     runner=None,
+    entrypoint: Optional[str] = None,
     requirements: Optional[Union[str, List[str]]] = None,
     extra_packages: Optional[List[str]] = None,
     output_dir: Optional[str] = None,
     dockerfile_path: Optional[str] = None,
     use_local_runtime: Optional[bool] = None,
+    platform: str = "unknown",
     **kwargs,
 ) -> Tuple[str, ProjectInfo]:
     """
     Create a detached bundle directory ready for execution.
 
+    All temporary files are created in cwd/.agentscope_runtime/ by default.
+
     Args:
         app: AgentApp instance to deploy
         runner: Runner instance to deploy
+        entrypoint: Entrypoint specification (e.g., "app.py" or
+                 "app.py:handler")
         requirements: Additional pip requirements (string or list)
         extra_packages: Additional Python packages to include
         output_dir: Output directory (creates temp dir if None)
@@ -64,8 +75,8 @@ def build_detached_app(
     if app is not None and runner is None:
         runner = ensure_runner_from_app(app)
 
-    if runner is None and app is None:
-        raise ValueError("Either app or runner must be provided")
+    if runner is None and app is None and entrypoint is None:
+        raise ValueError("Either app or runner or entrypoint must be provided")
 
     normalized_requirements = _normalize_requirements(requirements)
 
@@ -75,17 +86,18 @@ def build_detached_app(
             shutil.rmtree(build_root)
         build_root.mkdir(parents=True, exist_ok=True)
     else:
-        build_root = Path(
-            tempfile.mkdtemp(
-                prefix="agentscope_runtime_detached_",
-            ),
-        )
+        # Use generate_build_directory for consistent naming
+        build_root = generate_build_directory(platform)
+        build_root.mkdir(parents=True, exist_ok=True)
 
     package_path, project_info = package(
         app=app,
         runner=None if app is not None else runner,
+        entrypoint=entrypoint,
         output_dir=str(build_root),
         extra_packages=extra_packages,
+        requirements=normalized_requirements,
+        platform=platform,
         **kwargs,
     )
 
@@ -102,12 +114,7 @@ def build_detached_app(
     with zipfile.ZipFile(deployment_zip, "r") as archive:
         archive.extractall(project_root)
 
-    # Auto-detect if not specified
-    if use_local_runtime is None:
-        package_version = _get_package_version()
-        use_local_runtime = _is_dev_version(package_version)
-
-    _append_additional_requirements(
+    append_project_requirements(
         project_root,
         normalized_requirements,
         use_local_runtime=use_local_runtime,
@@ -146,10 +153,10 @@ def _normalize_requirements(
     return [str(item) for item in requirements]
 
 
-def _append_additional_requirements(
+def append_project_requirements(
     extraction_dir: Path,
-    additional_requirements: List[str],
-    use_local_runtime: bool = False,
+    additional_requirements: Optional[Union[str, list]],
+    use_local_runtime: Optional[bool] = False,
 ) -> None:
     """
     Append requirements to requirements.txt.
@@ -163,16 +170,15 @@ def _append_additional_requirements(
         use_local_runtime: If True, build and use local runtime wheel.
                           Useful for development when runtime is not released.
     """
+    # Auto-detect if not specified
+    if use_local_runtime is None:
+        use_local_runtime = os.getenv("USE_LOCAL_RUNTIME", "False") == "True"
+
     req_path = extraction_dir / "requirements.txt"
     package_version = _get_package_version()
 
-    # Auto-detect if we should use local runtime
-    should_use_local = use_local_runtime or (
-        package_version and _is_dev_version(package_version)
-    )
-
     with open(str(req_path), "w", encoding="utf-8") as f:
-        if should_use_local:
+        if use_local_runtime:
             # Create wheels subdirectory
             # Get base requirements from pyproject.toml
             runtime_source = _get_runtime_source_path()
@@ -203,8 +209,6 @@ def _append_additional_requirements(
                 "fastapi",
                 "uvicorn",
                 f"agentscope-runtime=={package_version}",
-                f"agentscope-runtime[sandbox]=={package_version}",
-                f"agentscope-runtime[deployment]=={package_version}",
                 "pydantic",
                 "jinja2",  # For template rendering
                 "psutil",  # For process management
@@ -218,6 +222,9 @@ def _append_additional_requirements(
         if not additional_requirements:
             additional_requirements = []
 
+        if isinstance(additional_requirements, str):
+            additional_requirements = additional_requirements.split(",")
+
         # Combine base requirements with user requirements
         all_requirements = sorted(
             list(
@@ -230,6 +237,72 @@ def _append_additional_requirements(
             f.write(f"{req}\n")
 
 
+def _parse_pyproject_toml(pyproject_path: Path) -> List[str]:
+    deps: List[str] = []
+    if not pyproject_path.is_file():
+        return deps
+    text = pyproject_path.read_text(encoding="utf-8")
+
+    try:
+        # Prefer stdlib tomllib (Python 3.11+)
+        if tomllib is None:
+            raise RuntimeError("tomllib not available")
+        data = tomllib.loads(text)
+        # PEP 621
+        proj = data.get("project") or {}
+        deps.extend(proj.get("dependencies") or [])
+        # Poetry fallback
+        poetry = (data.get("tool") or {}).get("poetry") or {}
+        poetry_deps = poetry.get("dependencies") or {}
+        for name, spec in poetry_deps.items():
+            if name.lower() == "python":
+                continue
+            if isinstance(spec, str):
+                deps.append(f"{name}{spec if spec.strip() else ''}")
+            elif isinstance(spec, dict):
+                version = spec.get("version")
+                if version:
+                    deps.append(f"{name}{version}")
+                else:
+                    deps.append(name)
+    except Exception:
+        # Minimal non-toml parser fallback
+        block_match = re.search(
+            r"dependencies\s*=\s*\[(.*?)\]",
+            text,
+            re.S | re.I,
+        )
+        if block_match:
+            block = block_match.group(1)
+            for m in re.finditer(r"['\"]([^'\"]+)['\"]", block):
+                deps.append(m.group(1))
+        # Poetry fallback: very limited, heuristic
+        poetry_block = re.search(
+            r"\[tool\.poetry\.dependencies\](.*?)\n\[",
+            text,
+            re.S,
+        )
+        if poetry_block:
+            for line in poetry_block.group(1).splitlines():
+                line = line.strip()
+                if not line or line.startswith("#"):
+                    continue
+                if ":" in line:
+                    # name = "^1.2.3"
+                    m = re.match(
+                        r"([A-Za-z0-9_.-]+)\s*=\s*['\"]([^'\"]+)['\"]",
+                        line,
+                    )
+                    if m and m.group(1).lower() != "python":
+                        deps.append(f"{m.group(1)}{m.group(2)}")
+                else:
+                    # name without version
+                    name = line.split("#")[0].strip()
+                    if name and name.lower() != "python":
+                        deps.append(name)
+    return deps
+
+
 def _get_package_version() -> str:
     """
     Get the package version from pyproject.toml file.
@@ -496,7 +569,9 @@ def _write_bundle_meta(bundle_dir: Path, entry_script: str) -> None:
     meta_path.write_text(json.dumps(meta, indent=2), encoding="utf-8")
 
 
-def get_bundle_entry_script(bundle_dir: Union[str, Path]) -> str:
+def get_bundle_entry_script(bundle_dir: Optional[Union[str, Path]]) -> str:
+    if bundle_dir is None:
+        return DEFAULT_ENTRYPOINT_FILE
     meta_path = Path(bundle_dir) / META_FILENAME
     if meta_path.exists():
         try:

agentscope_runtime/engine/deployers/utils/docker_image_utils/docker_image_builder.py

@@ -17,11 +17,13 @@ class RegistryConfig(BaseModel):
     registry_url: str = ""
     username: str = None
     password: str = None
-    namespace: str = "agentscope-runtime"
+    namespace: Optional[str] = "agentscope-runtime"
     image_pull_secret: str = None
 
     def get_full_url(self) -> str:
         # Handle different registry URL formats
+        if self.registry_url == "localhost":
+            return self.registry_url
         return f"{self.registry_url}/{self.namespace}"
 
 
@@ -201,27 +203,21 @@ class DockerImageBuilder:
                 error_msg,
             ) from e
 
-    def push_image(
+    def tag_image(
         self,
         image_name: str,
         registry_config: Optional[RegistryConfig] = None,
-        quiet: bool = False,
     ) -> str:
         """
-        Push image to registry.
+        Tag image with registry info.
 
         Args:
             image_name: Full image name to push
             registry_config: Optional registry config
                 (uses instance config if None)
-            quiet: Whether to suppress output
 
         Returns:
-            str: Full image name that was pushed
-
-        Raises:
-            subprocess.CalledProcessError: If push fails
-            ValueError: If no registry configuration is available
+              registry_image_name: Full image name with url
         """
         config = registry_config
         if not config:
@@ -240,6 +236,31 @@ class DockerImageBuilder:
             )
         else:
             registry_image_name = image_name
+        return registry_image_name
+
+    def push_image(
+        self,
+        image_name: str,
+        registry_config: Optional[RegistryConfig] = None,
+        quiet: bool = False,
+    ) -> str:
+        """
+        Push image to registry.
+
+        Args:
+            image_name: Full image name to push
+            registry_config: Optional registry config
+                (uses instance config if None)
+            quiet: Whether to suppress output
+
+        Returns:
+            str: Full image name that was pushed
+
+        Raises:
+            subprocess.CalledProcessError: If push fails
+            ValueError: If no registry configuration is available
+        """
+        registry_image_name = self.tag_image(image_name, registry_config)
 
         try:
             push_cmd = ["docker", "push", registry_image_name]

agentscope_runtime/engine/deployers/utils/docker_image_utils/dockerfile_generator.py

@@ -21,6 +21,7 @@ class DockerfileConfig(BaseModel):
     startup_command: Optional[str] = None
     health_check_endpoint: str = "/health"
     custom_template: Optional[str] = None
+    platform: Optional[str] = None
 
 
 class DockerfileGenerator:
@@ -31,7 +32,7 @@ class DockerfileGenerator:
 
     # Default Dockerfile template for Python applications
     DEFAULT_TEMPLATE = """# Use official Python runtime as base image
-FROM {base_image}
+FROM --platform={platform} {base_image}
 
 # Set working directory in container
 WORKDIR /app
@@ -43,15 +44,20 @@ ENV PYTHONUNBUFFERED=1
 # Configure package sources for better performance
 RUN rm -f /etc/apt/sources.list.d/*.list
 
-# 替换主源为阿里云
-RUN echo "deb https://mirrors.aliyun.com/debian/ bookworm main contrib " \\
-        "non-free non-free-firmware" > /etc/apt/sources.list && \\
-    echo "deb https://mirrors.aliyun.com/debian/ bookworm-updates main " \\
-         "contrib non-free non-free-firmware" >> /etc/apt/sources.list && \\
-    echo "deb https://mirrors.aliyun.com/debian-security/ " \\
-         "bookworm-security main contrib non-free " \\
+# add aliyun mirrors
+RUN echo "deb https://mirrors.aliyun.com/debian/ bookworm main contrib " \
+        "non-free non-free-firmware" > /etc/apt/sources.list && \
+    echo "deb https://mirrors.aliyun.com/debian/ bookworm-updates main " \
+         "contrib non-free non-free-firmware" >> /etc/apt/sources.list && \
+    echo "deb https://mirrors.aliyun.com/debian-security/ " \
+         "bookworm-security main contrib non-free " \
          "non-free-firmware" >> /etc/apt/sources.list
 
+# replace debian to aliyun
+RUN mkdir -p /etc/apt/sources.list.d && \
+    cat > /etc/apt/sources.list.d/debian.sources <<'EOF'
+EOF
+
 # Clean up package lists
 RUN rm -rf /var/lib/apt/lists/*
 
@@ -140,6 +146,7 @@ HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \\
             additional_packages_section=additional_packages_section,
             env_vars_section=env_vars_section,
             startup_command_section=startup_command_section,
+            platform=config.platform,
         )
 
         return content

agentscope_runtime/engine/deployers/utils/docker_image_utils/image_factory.py

@@ -28,7 +28,7 @@ class ImageConfig(BaseModel):
     # Package configuration
     requirements: Optional[List[str]] = None
     extra_packages: Optional[List[str]] = None
-    build_context_dir: str = "/tmp/k8s_build"
+    build_context_dir: Optional[str] = None
     endpoint_path: str = "/process"
     protocol_adapters: Optional[List] = None  # New: protocol adapters
     custom_endpoints: Optional[
@@ -171,6 +171,8 @@ class ImageFactory:
         app,
         runner: Optional[Runner],
         config: ImageConfig,
+        entrypoint: Optional[str] = None,
+        use_cache: bool = True,
     ) -> str:
         """
         Build a complete Docker image for the Runner.
@@ -181,9 +183,15 @@ class ImageFactory:
         3. Build Docker image
         4. Optionally push to registry
 
+        All temporary files are created in cwd/.agentscope_runtime/ by default.
+
         Args:
+            app: Agent app object
             runner: Runner object containing agent and managers
             config: Configuration for the image building process
+            entrypoint: Entrypoint specification (e.g., "app.py" or
+                "app.py:handler")
+            use_cache: Enable build cache (default: True)
 
         Returns:
             str: Full image name (with registry if pushed)
@@ -209,6 +217,7 @@ class ImageFactory:
                 port=config.port,
                 env_vars=config.env_vars,
                 startup_command=startup_command,
+                platform=config.platform,
             )
 
             dockerfile_path = self.dockerfile_generator.create_dockerfile(
@@ -222,10 +231,13 @@ class ImageFactory:
             project_dir, _ = build_detached_app(
                 app=app,
                 runner=runner,
+                entrypoint=entrypoint,
                 requirements=config.requirements,
                 extra_packages=config.extra_packages,
                 output_dir=config.build_context_dir,
                 dockerfile_path=dockerfile_path,
+                use_cache=use_cache,
+                platform="k8s",
             )
             is_updated = True
             logger.info(f"Project packaged: {project_dir}")
@@ -260,6 +272,15 @@ class ImageFactory:
                     config=build_config,
                     source_updated=is_updated,
                 )
+                logger.info(f"Image built: {full_image_name}")
+
+                # make sure tag the image if not push
+                registry_full_name = self.image_builder.tag_image(
+                    full_image_name,
+                    config.registry_config,
+                )
+                logger.info(f"Image tag to: {registry_full_name}")
+
                 logger.info(f"Image built locally: {full_image_name}")
 
             return full_image_name
@@ -276,6 +297,7 @@ class ImageFactory:
         self,
         app=None,
         runner: Optional[Runner] = None,
+        entrypoint: Optional[str] = None,
         requirements: Optional[Union[str, List[str]]] = None,
         extra_packages: Optional[List[str]] = None,
         base_image: str = "python:3.10-slim-bookworm",
@@ -291,14 +313,19 @@ class ImageFactory:
         host: str = "0.0.0.0",
         embed_task_processor: bool = True,
         extra_startup_args: Optional[Dict[str, Union[str, int, bool]]] = None,
+        use_cache: bool = True,
         **kwargs,
     ) -> str:
         """
         Simplified interface for building Runner images.
 
+        All temporary files are created in cwd/.agentscope_runtime/ by default.
+
         Args:
             app: agent app object
             runner: Runner object
+            entrypoint: Entrypoint specification (e.g., "app.py" or
+                    "app.py:handler")
             requirements: Python requirements
             extra_packages: Additional files to include
             base_image: Docker base image
@@ -311,6 +338,7 @@ class ImageFactory:
             host: Host to bind to (default: 0.0.0.0 for containers)
             embed_task_processor: Whether to embed task processor
             extra_startup_args: Additional startup arguments
+            use_cache: Enable build cache (default: True)
             **kwargs: Additional configuration options
 
         Returns:
@@ -348,7 +376,7 @@ class ImageFactory:
             **kwargs,
         )
 
-        return self._build_image(app, runner, config)
+        return self._build_image(app, runner, config, entrypoint, use_cache)
 
     def cleanup(self):
         """Clean up all temporary resources"""