agentengine-sdk-python 0.6.9__py3-none-any.whl → 0.8.0__py3-none-any.whl

ksadk/deployment/manager.py

@@ -3,10 +3,8 @@
 """
 
 from abc import ABC, abstractmethod
-from typing import Dict, Any, Literal
 from pathlib import Path
-import shutil
-import os
+from typing import Any, Dict, Literal
 
 from ksadk.builders.framework_requirements import (
     FASTAPI_REQUIREMENT,
@@ -17,12 +15,12 @@ from ksadk.builders.requirements_utils import merge_requirement_lists
 
 class BaseDeployer(ABC):
     """部署器基类"""
-    
+
     @abstractmethod
     def package(self, project_dir: str, detection_result: Any) -> Dict[str, Any]:
         """打包项目"""
         pass
-    
+
     @abstractmethod
     def deploy(self, package_info: Dict[str, Any], **kwargs) -> Dict[str, Any]:
         """部署"""
@@ -31,61 +29,59 @@ class BaseDeployer(ABC):
 
 class K8sDeployer(BaseDeployer):
     """K8s 部署器 (本地模拟)"""
-    
+
     def package(self, project_dir: str, detection_result: Any) -> Dict[str, Any]:
         """打包项目并生成 K8s 配置"""
         project_path = Path(project_dir)
         output_dir = project_path / ".ksadk" / "deploy"
         output_dir.mkdir(parents=True, exist_ok=True)
-        
+
         # 生成 Dockerfile
         dockerfile = self._generate_dockerfile(detection_result)
         dockerfile_path = output_dir / "Dockerfile"
         dockerfile_path.write_text(dockerfile)
-        
+
         # 生成 requirements.txt
         requirements = self._generate_requirements(detection_result)
         requirements_path = output_dir / "requirements.txt"
         requirements_path.write_text(requirements)
-        
+
         # 生成 K8s 部署配置
         k8s_config = self._generate_k8s_config()
         k8s_path = output_dir / "deployment.yaml"
         k8s_path.write_text(k8s_config)
-        
+
         # 生成启动脚本
         entrypoint = self._generate_entrypoint(detection_result)
         entrypoint_path = output_dir / "entrypoint.py"
         entrypoint_path.write_text(entrypoint)
-        
+
         return {
             "output_dir": str(output_dir),
             "dockerfile": str(dockerfile_path),
             "requirements": str(requirements_path),
             "config_path": str(k8s_path),
             "entrypoint": str(entrypoint_path),
-            "framework": detection_result.type.value
+            "framework": detection_result.type.value,
         }
-    
+
     def deploy(self, package_info: Dict[str, Any], **kwargs) -> Dict[str, Any]:
         """部署到 K8s (本地模拟)"""
         name = kwargs.get("name", "ksadk-agent")
         namespace = kwargs.get("namespace", "default")
         port = kwargs.get("port", 8000)
-        
+
         # 检查 kubectl 是否可用
         import subprocess
+
         try:
             result = subprocess.run(
-                ["kubectl", "version", "--client"],
-                capture_output=True,
-                text=True,
-                timeout=10
+                ["kubectl", "version", "--client"], capture_output=True, text=True, timeout=10
             )
             kubectl_available = result.returncode == 0
         except Exception:
             kubectl_available = False
-        
+
         if not kubectl_available:
             print("⚠️ kubectl 不可用，使用模拟部署模式")
             return {
@@ -93,9 +89,9 @@ class K8sDeployer(BaseDeployer):
                 "endpoint": f"http://localhost:{port}",
                 "message": "kubectl not available, deployment simulated",
                 "name": name,
-                "namespace": namespace
+                "namespace": namespace,
             }
-        
+
         # 实际部署到 K8s
         config_path = package_info.get("config_path")
         if config_path:
@@ -104,43 +100,35 @@ class K8sDeployer(BaseDeployer):
             config_content = config_content.replace("{{NAME}}", name)
             config_content = config_content.replace("{{NAMESPACE}}", namespace)
             config_content = config_content.replace("{{PORT}}", str(port))
-            
+
             temp_config = Path(package_info["output_dir"]) / "deployment_final.yaml"
             temp_config.write_text(config_content)
-            
+
             try:
                 result = subprocess.run(
                     ["kubectl", "apply", "-f", str(temp_config)],
                     capture_output=True,
                     text=True,
-                    timeout=60
+                    timeout=60,
                 )
-                
+
                 if result.returncode == 0:
                     return {
                         "status": "deployed",
                         "endpoint": f"http://{name}.{namespace}.svc.cluster.local:{port}",
                         "name": name,
                         "namespace": namespace,
-                        "kubectl_output": result.stdout
+                        "kubectl_output": result.stdout,
                     }
                 else:
-                    return {
-                        "status": "failed",
-                        "error": result.stderr,
-                        "name": name
-                    }
+                    return {"status": "failed", "error": result.stderr, "name": name}
             except Exception as e:
-                return {
-                    "status": "error",
-                    "error": str(e),
-                    "name": name
-                }
-        
+                return {"status": "error", "error": str(e), "name": name}
+
         return {"status": "error", "message": "No config path provided"}
-    
+
     def _generate_dockerfile(self, detection_result: Any) -> str:
-        return f'''FROM python:3.12-slim
+        return """FROM python:3.12-slim
 
 WORKDIR /app
 
@@ -152,8 +140,8 @@ COPY . .
 EXPOSE 8000
 
 CMD ["python", "entrypoint.py"]
-'''
-    
+"""
+
     def _generate_requirements(self, detection_result: Any) -> str:
         base_deps = [
             FASTAPI_REQUIREMENT,
@@ -161,14 +149,14 @@ CMD ["python", "entrypoint.py"]
             "python-dotenv>=1.0.0",
             "pydantic>=2.0.0",
         ]
-        
+
         framework = detection_result.type.value
         base_deps += minimal_requirements_for_framework(framework)
-        
+
         return "\n".join(merge_requirement_lists(base_deps))
-    
+
     def _generate_k8s_config(self) -> str:
-        return '''apiVersion: apps/v1
+        return """apiVersion: apps/v1
 kind: Deployment
 metadata:
   name: {{NAME}}
@@ -215,8 +203,8 @@ spec:
   - port: {{PORT}}
     targetPort: {{PORT}}
   type: ClusterIP
-'''
-    
+"""
+
     def _generate_entrypoint(self, detection_result: Any) -> str:
         package_name = Path(detection_result.package_path).name
         return f'''"""
@@ -255,7 +243,7 @@ runner = create_runner(detection_result, "/app")
 runner.load_agent()
 
 # 设置 Runner 到 FastAPI app
-set_runner(runner)
+set_runner(runner, loaded=True)
 
 if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=8000)
@@ -264,69 +252,79 @@ if __name__ == "__main__":
 
 class DockerDeployer(K8sDeployer):
     """Docker 部署器"""
-    
+
     def deploy(self, package_info: Dict[str, Any], **kwargs) -> Dict[str, Any]:
         """构建并运行 Docker 容器"""
         import subprocess
-        
+
         name = kwargs.get("name", "ksadk-agent")
         port = kwargs.get("port", 8000)
         output_dir = package_info.get("output_dir")
-        
+        if output_dir is None:
+            return {"status": "failed", "error": "package output_dir is missing"}
+
         # 构建镜像
         print(f"🔨 构建 Docker 镜像: {name}")
         try:
             result = subprocess.run(
-                ["docker", "build", "-t", name, "-f", package_info["dockerfile"], output_dir],
+                [
+                    "docker",
+                    "build",
+                    "-t",
+                    str(name),
+                    "-f",
+                    str(package_info["dockerfile"]),
+                    str(output_dir),
+                ],
                 capture_output=True,
                 text=True,
-                timeout=300
+                timeout=300,
             )
-            
+
             if result.returncode != 0:
                 return {"status": "failed", "error": result.stderr}
-            
-            print(f"✅ 镜像构建成功")
-            
+
+            print("✅ 镜像构建成功")
+
             # 运行容器
             result = subprocess.run(
                 ["docker", "run", "-d", "-p", f"{port}:8000", "--name", f"{name}-container", name],
                 capture_output=True,
                 text=True,
-                timeout=30
+                timeout=30,
             )
-            
+
             if result.returncode == 0:
                 return {
                     "status": "running",
                     "endpoint": f"http://localhost:{port}",
                     "container_id": result.stdout.strip()[:12],
-                    "name": name
+                    "name": name,
                 }
             else:
                 return {"status": "failed", "error": result.stderr}
-                
+
         except Exception as e:
             return {"status": "error", "error": str(e)}
 
 
 class DeploymentManager:
     """部署管理器工厂"""
-    
+
     _deployers = {
         "k8s": K8sDeployer,
         "docker": DockerDeployer,
     }
-    
+
     @classmethod
     def create(cls, target: Literal["k8s", "docker", "faas"]) -> BaseDeployer:
         """创建部署器"""
         if target == "faas":
             # FaaS 暂时使用 K8s 部署器模拟
             target = "k8s"
-        
+
         deployer_class = cls._deployers.get(target)
         if not deployer_class:
             raise ValueError(f"不支持的部署目标: {target}")
-        
+
         return deployer_class()