veadk-python 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

veadk/integrations/ve_cr/ve_cr.py

@@ -0,0 +1,220 @@
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import time
+
+from veadk.consts import (
+    DEFAULT_CR_INSTANCE_NAME,
+    DEFAULT_CR_NAMESPACE_NAME,
+    DEFAULT_CR_REPO_NAME,
+)
+from veadk.utils.logger import get_logger
+from veadk.utils.volcengine_sign import ve_request
+
+logger = get_logger(__name__)
+
+
+class VeCR:
+    def __init__(self, access_key: str, secret_key: str, region: str = "cn-beijing"):
+        self.ak = access_key
+        self.sk = secret_key
+        self.region = region
+        assert region in ["cn-beijing", "cn-guangzhou", "cn-shanghai"]
+        self.version = "2022-05-12"
+
+    def _create_instance(self, instance_name: str = DEFAULT_CR_INSTANCE_NAME) -> str:
+        """
+        create cr instance
+
+        Args:
+            instance_name: cr instance name
+
+        Returns:
+            cr instance name
+        """
+        status = self._check_instance(instance_name)
+        if status != "NONEXIST":
+            logger.debug(f"cr instance {instance_name} already running")
+            return instance_name
+        response = ve_request(
+            request_body={
+                "Name": instance_name,
+                "ResourceTags": [
+                    {"Key": "provider", "Value": "veadk"},
+                ],
+            },
+            action="CreateRegistry",
+            ak=self.ak,
+            sk=self.sk,
+            service="cr",
+            version=self.version,
+            region=self.region,
+            host=f"cr.{self.region}.volcengineapi.com",
+        )
+        logger.debug(f"create cr instance {instance_name}: {response}")
+
+        if "Error" in response["ResponseMetadata"]:
+            error_code = response["ResponseMetadata"]["Error"]["Code"]
+            error_message = response["ResponseMetadata"]["Error"]["Message"]
+            if error_code == "AlreadyExists.Registry":
+                logger.debug(f"cr instance {instance_name} already exists")
+                return instance_name
+            else:
+                logger.error(
+                    f"Error create cr instance {instance_name}: {error_code} {error_message}"
+                )
+                raise ValueError(
+                    f"Error create cr instance {instance_name}: {error_code} {error_message}"
+                )
+
+        while True:
+            status = self._check_instance(instance_name)
+            if status == "Running":
+                break
+            elif status == "Failed":
+                raise ValueError(f"cr instance {instance_name} create failed")
+            else:
+                logger.debug(f"cr instance status: {status}")
+                time.sleep(30)
+
+        return instance_name
+
+    def _check_instance(self, instance_name: str) -> str:
+        """
+        check cr instance status
+
+        Args:
+            instance_name: cr instance name
+
+        Returns:
+            cr instance status
+        """
+        response = ve_request(
+            request_body={
+                "Filter": {
+                    "Names": [instance_name],
+                }
+            },
+            action="ListRegistries",
+            ak=self.ak,
+            sk=self.sk,
+            service="cr",
+            version=self.version,
+            region=self.region,
+            host=f"cr.{self.region}.volcengineapi.com",
+        )
+        logger.debug(f"check cr instance {instance_name}: {response}")
+
+        try:
+            if response["Result"]["TotalCount"] == 0:
+                return "NONEXIST"
+            return response["Result"]["Items"][0]["Status"]["Phase"]
+        except Exception as _:
+            raise ValueError(f"Error check cr instance {instance_name}: {response}")
+
+    def _create_namespace(
+        self,
+        instance_name: str = DEFAULT_CR_INSTANCE_NAME,
+        namespace_name: str = DEFAULT_CR_NAMESPACE_NAME,
+    ) -> str:
+        """
+        create cr namespace
+
+        Args:
+            instance_name: cr instance name
+            namespace_name: cr namespace name
+
+        Returns:
+            cr namespace name
+        """
+        response = ve_request(
+            request_body={
+                "Name": namespace_name,
+                "Registry": instance_name,
+            },
+            action="CreateNamespace",
+            ak=self.ak,
+            sk=self.sk,
+            service="cr",
+            version=self.version,
+            region=self.region,
+            host=f"cr.{self.region}.volcengineapi.com",
+        )
+        logger.debug(f"create cr namespace {namespace_name}: {response}")
+
+        if "Error" in response["ResponseMetadata"]:
+            error_code = response["ResponseMetadata"]["Error"]["Code"]
+            error_message = response["ResponseMetadata"]["Error"]["Message"]
+            if error_code == "AlreadyExists.Namespace":
+                logger.warning(f"cr namespace {namespace_name} already exists")
+                return namespace_name
+            else:
+                logger.error(
+                    f"Error create cr namespace {namespace_name}: {error_code} {error_message}"
+                )
+                raise ValueError(
+                    f"Error create cr namespace {namespace_name}: {error_code} {error_message}"
+                )
+
+        return namespace_name
+
+    def _create_repo(
+        self,
+        instance_name: str = DEFAULT_CR_INSTANCE_NAME,
+        namespace_name: str = DEFAULT_CR_NAMESPACE_NAME,
+        repo_name: str = DEFAULT_CR_REPO_NAME,
+    ) -> str:
+        """
+        create cr repo
+
+        Args:
+            instance_name: cr instance name
+            namespace_name: cr namespace name
+            repo_name: cr repo name
+
+        Returns:
+            cr repo name
+        """
+        response = ve_request(
+            request_body={
+                "Name": repo_name,
+                "Registry": instance_name,
+                "Namespace": namespace_name,
+                "Description": "veadk cr repo",
+            },
+            action="CreateRepository",
+            ak=self.ak,
+            sk=self.sk,
+            service="cr",
+            version=self.version,
+            region=self.region,
+            host=f"cr.{self.region}.volcengineapi.com",
+        )
+        logger.debug(f"create cr repo {repo_name}: {response}")
+
+        if "Error" in response["ResponseMetadata"]:
+            error_code = response["ResponseMetadata"]["Error"]["Code"]
+            error_message = response["ResponseMetadata"]["Error"]["Message"]
+            if error_code == "AlreadyExists.Repository":
+                logger.debug(f"cr repo {repo_name} already exists")
+                return repo_name
+            else:
+                logger.error(
+                    f"Error create cr repo {repo_name}: {error_code} {error_message}"
+                )
+                raise ValueError(
+                    f"Error create cr repo {repo_name}: {error_code} {error_message}"
+                )
+
+        return repo_name

veadk/integrations/ve_faas/template/cookiecutter.json

@@ -1,11 +1,12 @@
 {
   "local_dir_name": "veadk_vefaas_proj",
-  "app_name": "weather-report",
+  "app_name": "weather_report",
   "agent_module_name": "weather_agent",
   "short_term_memory_backend": "local",
   "vefaas_application_name": "weather-reporter",
   "veapig_instance_name": "",
   "veapig_service_name": "",
   "veapig_upstream_name": "",
-  "use_adk_web": false
+  "use_adk_web": false,
+  "veadk_version": ""
 }

veadk/integrations/ve_faas/template/{{cookiecutter.local_dir_name}}/deploy.py

@@ -95,8 +95,8 @@ async def main():
         message = "How is the weather like in Beijing?"
         print(f"Test message: {message}")
 
-        await _send_msg_with_a2a(cloud_app=cloud_app, message=message)
-        await _send_msg_with_mcp(cloud_app=cloud_app, message=message)
+        # await _send_msg_with_a2a(cloud_app=cloud_app, message=message)
+        # await _send_msg_with_mcp(cloud_app=cloud_app, message=message)
 
 
 if __name__ == "__main__":

veadk/integrations/ve_faas/template/{{cookiecutter.local_dir_name}}/src/agent.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from {{ cookiecutter.app_name|replace('-', '_') }}.agent import agent # type: ignore
+from {{ cookiecutter.app_name }}.agent import agent # type: ignore
 
 from veadk.memory.short_term_memory import ShortTermMemory
 from veadk.types import AgentRunConfig

veadk/integrations/ve_faas/template/{{cookiecutter.local_dir_name}}/src/app.py

@@ -36,6 +36,8 @@ from veadk.tracing.telemetry.exporters.tls_exporter import TLSExporter
 from veadk.tracing.telemetry.opentelemetry_tracer import OpentelemetryTracer
 from veadk.types import AgentRunConfig
 from veadk.utils.logger import get_logger
+from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
+from opentelemetry import context
 
 logger = get_logger(__name__)
 
@@ -117,6 +119,8 @@ async def agent_card() -> dict:
     agent_card = await agent_card_builder.build()
     return agent_card.model_dump()
 
+async def get_cozeloop_space_id() -> dict:
+    return {"space_id": os.getenv("OBSERVABILITY_OPENTELEMETRY_COZELOOP_SERVICE_NAME", default="")}
 
 load_tracer()
 
@@ -132,7 +136,7 @@ a2a_app = init_app(
 
 a2a_app.post("/run_agent", operation_id="run_agent", tags=["mcp"])(run_agent_func)
 a2a_app.get("/agent_card", operation_id="agent_card", tags=["mcp"])(agent_card)
-
+a2a_app.get("/get_cozeloop_space_id", operation_id="get_cozeloop_space_id", tags=["mcp"])(get_cozeloop_space_id)
 
 # === Build mcp server ===
 
@@ -159,6 +163,25 @@ app = FastAPI(
     redoc_url=None
 )
 
+@app.middleware("http")
+async def otel_context_middleware(request, call_next):
+    carrier = {
+        "traceparent": request.headers.get("Traceparent"),
+        "tracestate": request.headers.get("Tracestate"),
+    }
+    logger.debug(f"carrier: {carrier}")
+    if carrier["traceparent"] is None:
+        return await call_next(request)
+    else:
+        ctx = TraceContextTextMapPropagator().extract(carrier=carrier)
+        logger.debug(f"ctx: {ctx}")
+        token = context.attach(ctx)
+        try:
+            response = await call_next(request)
+        finally:
+            context.detach(token)
+    return response
+
 # Mount A2A routes to main app
 for route in a2a_app.routes:
     app.routes.append(route)

veadk/integrations/ve_faas/template/{{cookiecutter.local_dir_name}}/src/requirements.txt

@@ -1 +1,3 @@
-veadk-python
+veadk-python=={{ cookiecutter.veadk_version }}
+fastapi
+uvicorn[standard]

veadk/integrations/ve_faas/template/{{cookiecutter.local_dir_name}}/src/run.sh

@@ -16,6 +16,7 @@ export SERVER_HOST=$HOST
 export SERVER_PORT=$PORT
 
 export PYTHONPATH=$PYTHONPATH:./site-packages
+
 # Parse arguments
 while [[ $# -gt 0 ]]; do
     case $1 in
@@ -33,18 +34,6 @@ while [[ $# -gt 0 ]]; do
     esac
 done
 
-# in case of deployment deps not installed in user's requirements.txt
-if pip list | grep -q "^fastapi \|^uvicorn "; then
-    echo "fastapi and uvicorn already installed"
-else
-    python3 -m pip install uvicorn[standard] fastapi
-fi
-
-# Check if MODEL_AGENT_API_KEY is set
-if [ -z "$MODEL_AGENT_API_KEY" ]; then
-    echo "MODEL_AGENT_API_KEY is not set. Please set it in your environment variables."
-    exit 1
-fi
 
 USE_ADK_WEB=${USE_ADK_WEB:-False}