cap-sdk-python 2.5.3__tar.gz → 2.5.4__tar.gz

{cap_sdk_python-2.5.3 → cap_sdk_python-2.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cap-sdk-python
-Version: 2.5.3
+Version: 2.5.4
 Summary: CAP (Cordum Agent Protocol) Python SDK
 Author-email: Cordum <eng@cordum.io>
 License-Expression: Apache-2.0

{cap_sdk_python-2.5.3 → cap_sdk_python-2.5.4}/cap/__init__.py

@@ -35,6 +35,19 @@ from .bus import connect_nats
 from .runtime import Agent, Context, BlobStore, RedisBlobStore, InMemoryBlobStore
 from .middleware import Middleware, NextFn, logging_middleware
 from .metrics import MetricsHook, NoopMetrics
+from .heartbeat import (
+    heartbeat_payload,
+    heartbeat_payload_with_memory,
+    heartbeat_payload_with_progress,
+    emit_heartbeat,
+    heartbeat_loop,
+)
+from .progress import (
+    progress_payload,
+    cancel_payload,
+    emit_progress,
+    emit_cancel,
+)
 from .validate import (
     ValidationError,
     validate_job_request,
@@ -88,6 +101,15 @@ __all__ = [
     "logging_middleware",
     "MetricsHook",
     "NoopMetrics",
+    "heartbeat_payload",
+    "heartbeat_payload_with_memory",
+    "heartbeat_payload_with_progress",
+    "emit_heartbeat",
+    "heartbeat_loop",
+    "progress_payload",
+    "cancel_payload",
+    "emit_progress",
+    "emit_cancel",
     "ValidationError",
     "validate_job_request",
     "validate_job_result",

cap_sdk_python-2.5.4/cap/heartbeat.py

@@ -0,0 +1,153 @@
+"""Heartbeat helpers for CAP Python SDK.
+
+These helpers build and publish heartbeat BusPacket envelopes.
+"""
+
+import asyncio
+import logging
+from typing import Callable, Optional
+
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric import ec
+from google.protobuf import timestamp_pb2
+
+from cap.client import DEFAULT_PROTOCOL_VERSION
+from cap.metrics import MetricsHook
+from cap.pb.cordum.agent.v1 import buspacket_pb2, heartbeat_pb2
+from cap.subjects import SUBJECT_HEARTBEAT
+
+_logger = logging.getLogger("cap.heartbeat")
+
+
+def heartbeat_payload(
+    worker_id: str,
+    pool: str,
+    active_jobs: int,
+    max_parallel: int,
+    cpu_load: float,
+) -> bytes:
+    """Build a heartbeat payload with CPU utilization only."""
+    return heartbeat_payload_with_progress(
+        worker_id=worker_id,
+        pool=pool,
+        active_jobs=active_jobs,
+        max_parallel=max_parallel,
+        cpu_load=cpu_load,
+    )
+
+
+def heartbeat_payload_with_memory(
+    worker_id: str,
+    pool: str,
+    active_jobs: int,
+    max_parallel: int,
+    cpu_load: float,
+    memory_load: float,
+) -> bytes:
+    """Build a heartbeat payload including memory utilization."""
+    return heartbeat_payload_with_progress(
+        worker_id=worker_id,
+        pool=pool,
+        active_jobs=active_jobs,
+        max_parallel=max_parallel,
+        cpu_load=cpu_load,
+        memory_load=memory_load,
+    )
+
+
+def heartbeat_payload_with_progress(
+    worker_id: str,
+    pool: str,
+    active_jobs: int,
+    max_parallel: int,
+    cpu_load: float,
+    memory_load: float = 0.0,
+    progress_pct: int = 0,
+    last_memo: str = "",
+) -> bytes:
+    """Build a heartbeat payload including optional progress fields."""
+    ts = timestamp_pb2.Timestamp()
+    ts.GetCurrentTime()
+
+    packet = buspacket_pb2.BusPacket()
+    packet.sender_id = worker_id
+    packet.protocol_version = DEFAULT_PROTOCOL_VERSION
+    packet.created_at.CopyFrom(ts)
+    packet.heartbeat.CopyFrom(
+        heartbeat_pb2.Heartbeat(
+            worker_id=worker_id,
+            pool=pool,
+            active_jobs=active_jobs,
+            max_parallel_jobs=max_parallel,
+            cpu_load=cpu_load,
+            memory_load=memory_load,
+            progress_pct=progress_pct,
+            last_memo=last_memo,
+        )
+    )
+    return packet.SerializeToString(deterministic=True)
+
+
+async def emit_heartbeat(
+    nc,
+    payload: bytes,
+    private_key: Optional[ec.EllipticCurvePrivateKey] = None,
+) -> None:
+    """Publish one heartbeat packet to the heartbeat subject."""
+    data = payload
+    if private_key is not None:
+        packet = buspacket_pb2.BusPacket()
+        packet.ParseFromString(payload)
+        packet.ClearField("signature")
+        unsigned_data = packet.SerializeToString(deterministic=True)
+        packet.signature = private_key.sign(unsigned_data, ec.ECDSA(hashes.SHA256()))
+        data = packet.SerializeToString(deterministic=True)
+
+    await nc.publish(SUBJECT_HEARTBEAT, data)
+
+
+async def heartbeat_loop(
+    nc,
+    payload_fn: Callable[[], bytes],
+    interval: float = 5.0,
+    private_key: Optional[ec.EllipticCurvePrivateKey] = None,
+    metrics: MetricsHook | None = None,
+    cancel_event: asyncio.Event | None = None,
+) -> None:
+    """Emit heartbeat packets periodically until cancelled."""
+    sleep_interval = max(0.0, interval)
+
+    while True:
+        if cancel_event is not None and cancel_event.is_set():
+            return
+
+        if cancel_event is None:
+            await asyncio.sleep(sleep_interval)
+        else:
+            sleep_task = asyncio.create_task(asyncio.sleep(sleep_interval))
+            cancel_task = asyncio.create_task(cancel_event.wait())
+            done, pending = await asyncio.wait(
+                {sleep_task, cancel_task},
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+
+            for task in pending:
+                task.cancel()
+            if pending:
+                await asyncio.gather(*pending, return_exceptions=True)
+
+            if cancel_task in done and cancel_event.is_set():
+                return
+
+        try:
+            payload = payload_fn()
+            await emit_heartbeat(nc=nc, payload=payload, private_key=private_key)
+            if metrics is not None:
+                packet = buspacket_pb2.BusPacket()
+                packet.ParseFromString(payload)
+                worker_id = packet.heartbeat.worker_id or packet.sender_id
+                metrics.on_heartbeat_sent(worker_id)
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            _logger.exception("heartbeat emission failed")

{cap_sdk_python-2.5.3 → cap_sdk_python-2.5.4}/cap/pb/cordum/agent/v1/alert_pb2_grpc.py

@@ -4,7 +4,7 @@ import grpc
 import warnings
 
 
-GRPC_GENERATED_VERSION = '1.78.0'
+GRPC_GENERATED_VERSION = '1.78.1'
 GRPC_VERSION = grpc.__version__
 _version_not_supported = False
 

{cap_sdk_python-2.5.3 → cap_sdk_python-2.5.4}/cap/pb/cordum/agent/v1/buspacket_pb2_grpc.py

@@ -4,7 +4,7 @@ import grpc
 import warnings
 
 
-GRPC_GENERATED_VERSION = '1.78.0'
+GRPC_GENERATED_VERSION = '1.78.1'
 GRPC_VERSION = grpc.__version__
 _version_not_supported = False
 

{cap_sdk_python-2.5.3 → cap_sdk_python-2.5.4}/cap/pb/cordum/agent/v1/handshake_pb2_grpc.py

@@ -4,7 +4,7 @@ import grpc
 import warnings
 
 
-GRPC_GENERATED_VERSION = '1.78.0'
+GRPC_GENERATED_VERSION = '1.78.1'
 GRPC_VERSION = grpc.__version__
 _version_not_supported = False
 

{cap_sdk_python-2.5.3 → cap_sdk_python-2.5.4}/cap/pb/cordum/agent/v1/heartbeat_pb2_grpc.py

@@ -4,7 +4,7 @@ import grpc
 import warnings
 
 
-GRPC_GENERATED_VERSION = '1.78.0'
+GRPC_GENERATED_VERSION = '1.78.1'
 GRPC_VERSION = grpc.__version__
 _version_not_supported = False
 

{cap_sdk_python-2.5.3 → cap_sdk_python-2.5.4}/cap/pb/cordum/agent/v1/job_pb2_grpc.py

@@ -4,7 +4,7 @@ import grpc
 import warnings
 
 
-GRPC_GENERATED_VERSION = '1.78.0'
+GRPC_GENERATED_VERSION = '1.78.1'
 GRPC_VERSION = grpc.__version__
 _version_not_supported = False
 

{cap_sdk_python-2.5.3 → cap_sdk_python-2.5.4}/cap/pb/cordum/agent/v1/safety_pb2_grpc.py

@@ -5,7 +5,7 @@ import warnings
 
 from cordum.agent.v1 import safety_pb2 as cordum_dot_agent_dot_v1_dot_safety__pb2
 
-GRPC_GENERATED_VERSION = '1.78.0'
+GRPC_GENERATED_VERSION = '1.78.1'
 GRPC_VERSION = grpc.__version__
 _version_not_supported = False
 

cap_sdk_python-2.5.4/cap/progress.py

@@ -0,0 +1,100 @@
+"""Progress and cancel emission helpers for CAP Python SDK.
+
+These helpers build and publish progress/cancel BusPacket envelopes.
+"""
+
+from typing import Optional
+
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric import ec
+from google.protobuf import timestamp_pb2
+
+from cap.client import DEFAULT_PROTOCOL_VERSION
+from cap.pb.cordum.agent.v1 import buspacket_pb2, job_pb2
+from cap.subjects import SUBJECT_CANCEL, SUBJECT_PROGRESS
+
+
+def progress_payload(
+    sender_id: str,
+    job_id: str,
+    step_id: str,
+    percent: int,
+    message: str,
+) -> bytes:
+    """Build a progress payload wrapped in a BusPacket envelope."""
+    ts = timestamp_pb2.Timestamp()
+    ts.GetCurrentTime()
+
+    packet = buspacket_pb2.BusPacket()
+    packet.sender_id = sender_id
+    packet.protocol_version = DEFAULT_PROTOCOL_VERSION
+    packet.created_at.CopyFrom(ts)
+    packet.job_progress.CopyFrom(
+        job_pb2.JobProgress(
+            job_id=job_id,
+            step_id=step_id,
+            percent=percent,
+            message=message,
+        )
+    )
+    return packet.SerializeToString(deterministic=True)
+
+
+def cancel_payload(
+    sender_id: str,
+    job_id: str,
+    reason: str,
+    requested_by: str,
+) -> bytes:
+    """Build a cancel payload wrapped in a BusPacket envelope."""
+    ts = timestamp_pb2.Timestamp()
+    ts.GetCurrentTime()
+
+    packet = buspacket_pb2.BusPacket()
+    packet.sender_id = sender_id
+    packet.protocol_version = DEFAULT_PROTOCOL_VERSION
+    packet.created_at.CopyFrom(ts)
+    packet.job_cancel.CopyFrom(
+        job_pb2.JobCancel(
+            job_id=job_id,
+            reason=reason,
+            requested_by=requested_by,
+        )
+    )
+    return packet.SerializeToString(deterministic=True)
+
+
+async def emit_progress(
+    nc,
+    payload: bytes,
+    private_key: Optional[ec.EllipticCurvePrivateKey] = None,
+) -> None:
+    """Publish one progress packet to the progress subject."""
+    data = payload
+    if private_key is not None:
+        packet = buspacket_pb2.BusPacket()
+        packet.ParseFromString(payload)
+        packet.ClearField("signature")
+        unsigned_data = packet.SerializeToString(deterministic=True)
+        packet.signature = private_key.sign(unsigned_data, ec.ECDSA(hashes.SHA256()))
+        data = packet.SerializeToString(deterministic=True)
+
+    await nc.publish(SUBJECT_PROGRESS, data)
+
+
+async def emit_cancel(
+    nc,
+    payload: bytes,
+    private_key: Optional[ec.EllipticCurvePrivateKey] = None,
+) -> None:
+    """Publish one cancel packet to the cancel subject."""
+    data = payload
+    if private_key is not None:
+        packet = buspacket_pb2.BusPacket()
+        packet.ParseFromString(payload)
+        packet.ClearField("signature")
+        unsigned_data = packet.SerializeToString(deterministic=True)
+        packet.signature = private_key.sign(unsigned_data, ec.ECDSA(hashes.SHA256()))
+        data = packet.SerializeToString(deterministic=True)
+
+    await nc.publish(SUBJECT_CANCEL, data)

{cap_sdk_python-2.5.3 → cap_sdk_python-2.5.4}/cap/runtime.py

@@ -26,6 +26,7 @@ except Exception:  # pragma: no cover - optional until runtime used
 from cap.subjects import SUBJECT_RESULT
 from cap.errors import InvalidInputError, MalformedPacketError, SignatureInvalidError, SignatureMissingError
 from cap.metrics import MetricsHook, NoopMetrics
+from cap.heartbeat import heartbeat_loop, heartbeat_payload
 
 DEFAULT_PROTOCOL_VERSION = 1
 
@@ -165,6 +166,11 @@ class Agent:
         public_keys: Optional[Dict[str, ec.EllipticCurvePublicKey]] = None,
         private_key: Optional[ec.EllipticCurvePrivateKey] = None,
         sender_id: str = "cap-runtime",
+        worker_id: Optional[str] = None,
+        pool: str = "",
+        max_parallel: int = 1,
+        heartbeat_interval: float = 5.0,
+        heartbeat_payload_fn: Optional[Callable[[], bytes]] = None,
         retries: int = 0,
         io_timeout: Optional[float] = 5.0,
         max_context_bytes: Optional[int] = 2 * 1024 * 1024,
@@ -178,7 +184,11 @@ class Agent:
         self._store = store
         self._public_keys = public_keys
         self._private_key = private_key
-        self._sender_id = sender_id
+        self._sender_id = worker_id or sender_id
+        self._pool = pool
+        self._max_parallel = max(1, max_parallel)
+        self._heartbeat_interval = heartbeat_interval if heartbeat_interval > 0 else 5.0
+        self._heartbeat_payload_fn = heartbeat_payload_fn
         self._default_retries = max(0, retries)
         self._io_timeout = io_timeout if io_timeout and io_timeout > 0 else None
         self._max_context_bytes = max_context_bytes if max_context_bytes and max_context_bytes > 0 else None
@@ -189,6 +199,9 @@ class Agent:
         self._handlers: Dict[str, HandlerSpec] = {}
         self._middlewares: list = []
         self._nc = None
+        self._active_jobs: set[str] = set()
+        self._heartbeat_cancel_event: Optional[asyncio.Event] = None
+        self._heartbeat_task: Optional[asyncio.Task[Any]] = None
 
     def use(self, *middlewares) -> None:
         """Append middleware to the agent. Middleware executes in registration order before the handler."""
@@ -247,13 +260,45 @@ class Agent:
         for topic, spec in self._handlers.items():
             await self._nc.subscribe(topic, queue=topic, cb=lambda msg, s=spec: asyncio.create_task(self._on_msg(msg, s)))
 
+        if self._heartbeat_task is None or self._heartbeat_task.done():
+            self._heartbeat_cancel_event = asyncio.Event()
+            payload_fn = self._heartbeat_payload_fn or self._default_heartbeat_payload
+            self._heartbeat_task = asyncio.create_task(
+                heartbeat_loop(
+                    nc=self._nc,
+                    payload_fn=payload_fn,
+                    interval=self._heartbeat_interval,
+                    private_key=self._private_key,
+                    metrics=self._metrics,
+                    cancel_event=self._heartbeat_cancel_event,
+                )
+            )
+
     async def close(self) -> None:
         """Drain the NATS connection and close the blob store."""
+        if self._heartbeat_cancel_event is not None:
+            self._heartbeat_cancel_event.set()
+        if self._heartbeat_task is not None:
+            try:
+                await self._heartbeat_task
+            finally:
+                self._heartbeat_task = None
+                self._heartbeat_cancel_event = None
+
         if self._nc is not None:
             await self._nc.drain()
         if self._store is not None:
             await self._store.close()
 
+    def _default_heartbeat_payload(self) -> bytes:
+        return heartbeat_payload(
+            worker_id=self._sender_id,
+            pool=self._pool,
+            active_jobs=len(self._active_jobs),
+            max_parallel=self._max_parallel,
+            cpu_load=0.0,
+        )
+
     async def run(self) -> None:
         """Start the agent and block until interrupted."""
         await self.start()
@@ -293,99 +338,103 @@ class Agent:
         if not req.job_id:
             return
 
-        self._metrics.on_job_received(req.job_id, req.topic)
-
-        ctx_logger = logging.LoggerAdapter(
-            self._logger,
-            {
-                "job_id": req.job_id,
-                "trace_id": packet.trace_id,
-                "topic": req.topic,
-                "sender_id": packet.sender_id,
-            },
-        )
-        ctx = Context(job=req, packet=packet, logger=ctx_logger)
-
-        store = self._store
-        if store is None:
-            ctx_logger.error("blob store not initialized")
-            return
-
+        self._active_jobs.add(req.job_id)
         try:
-            key = key_from_pointer(req.context_ptr)
-            payload = await self._with_timeout(store.get(key), "context fetch")
-            if payload is None:
-                raise ValueError("context not found")
-            if self._max_context_bytes is not None and len(payload) > self._max_context_bytes:
-                raise ValueError("context exceeds max size")
-        except Exception as exc:
-            await self._publish_failure(ctx, req, str(exc), execution_ms=0)
-            return
+            self._metrics.on_job_received(req.job_id, req.topic)
+
+            ctx_logger = logging.LoggerAdapter(
+                self._logger,
+                {
+                    "job_id": req.job_id,
+                    "trace_id": packet.trace_id,
+                    "topic": req.topic,
+                    "sender_id": packet.sender_id,
+                },
+            )
+            ctx = Context(job=req, packet=packet, logger=ctx_logger)
 
-        try:
-            raw = json.loads(payload.decode("utf-8"))
-        except Exception as exc:
-            await self._publish_failure(ctx, req, f"context decode failed: {exc}", execution_ms=0)
-            return
+            store = self._store
+            if store is None:
+                ctx_logger.error("blob store not initialized")
+                return
 
-        try:
-            input_data = self._validate_input(spec, raw)
-        except Exception as exc:
-            await self._publish_failure(ctx, req, f"input validation failed: {exc}", execution_ms=0)
-            return
+            try:
+                key = key_from_pointer(req.context_ptr)
+                payload = await self._with_timeout(store.get(key), "context fetch")
+                if payload is None:
+                    raise ValueError("context not found")
+                if self._max_context_bytes is not None and len(payload) > self._max_context_bytes:
+                    raise ValueError("context exceeds max size")
+            except Exception as exc:
+                await self._publish_failure(ctx, req, str(exc), execution_ms=0)
+                return
 
-        # Build middleware chain: outermost first, terminal calls handler.
-        async def _terminal(c: Context, d: Any) -> Any:
-            result = spec.func(c, d)
-            if asyncio.iscoroutine(result):
-                result = await result
-            return result
-
-        chain = _terminal
-        for mw in reversed(self._middlewares):
-            _next = chain
-            chain = (lambda m, n: (lambda c, d: m(c, d, n)))(mw, _next)
-
-        start_time = time.monotonic()
-        error: Optional[str] = None
-        output: Any = None
-        for attempt in range(spec.retries + 1):
             try:
-                output = await chain(ctx, input_data)
-                output = self._validate_output(spec, output)
-                error = None
-                break
+                raw = json.loads(payload.decode("utf-8"))
             except Exception as exc:
-                error = str(exc)
-                ctx_logger.warning("handler failed (attempt %d/%d): %s", attempt + 1, spec.retries + 1, exc)
-                if attempt >= spec.retries:
-                    break
+                await self._publish_failure(ctx, req, f"context decode failed: {exc}", execution_ms=0)
+                return
 
-        elapsed_ms = int((time.monotonic() - start_time) * 1000)
-        if error is not None:
-            await self._publish_failure(ctx, req, error, execution_ms=elapsed_ms)
-            return
+            try:
+                input_data = self._validate_input(spec, raw)
+            except Exception as exc:
+                await self._publish_failure(ctx, req, f"input validation failed: {exc}", execution_ms=0)
+                return
 
-        try:
-            result_payload = self._serialize_output(output)
-            if self._max_result_bytes is not None and len(result_payload) > self._max_result_bytes:
-                raise ValueError("result exceeds max size")
-            result_key = f"res:{req.job_id}"
-            await self._with_timeout(store.set(result_key, result_payload), "result write")
-            result_ptr = pointer_for_key(result_key)
-        except Exception as exc:
-            await self._publish_failure(ctx, req, f"result write failed: {exc}", execution_ms=elapsed_ms)
-            return
+            # Build middleware chain: outermost first, terminal calls handler.
+            async def _terminal(c: Context, d: Any) -> Any:
+                result = spec.func(c, d)
+                if asyncio.iscoroutine(result):
+                    result = await result
+                return result
+
+            chain = _terminal
+            for mw in reversed(self._middlewares):
+                _next = chain
+                chain = (lambda m, n: (lambda c, d: m(c, d, n)))(mw, _next)
+
+            start_time = time.monotonic()
+            error: Optional[str] = None
+            output: Any = None
+            for attempt in range(spec.retries + 1):
+                try:
+                    output = await chain(ctx, input_data)
+                    output = self._validate_output(spec, output)
+                    error = None
+                    break
+                except Exception as exc:
+                    error = str(exc)
+                    ctx_logger.warning("handler failed (attempt %d/%d): %s", attempt + 1, spec.retries + 1, exc)
+                    if attempt >= spec.retries:
+                        break
+
+            elapsed_ms = int((time.monotonic() - start_time) * 1000)
+            if error is not None:
+                await self._publish_failure(ctx, req, error, execution_ms=elapsed_ms)
+                return
 
-        self._metrics.on_job_completed(req.job_id, elapsed_ms, "SUCCEEDED")
-        result = job_pb2.JobResult(
-            job_id=req.job_id,
-            status=job_pb2.JOB_STATUS_SUCCEEDED,
-            result_ptr=result_ptr,
-            worker_id=self._sender_id,
-            execution_ms=elapsed_ms,
-        )
-        await self._publish_result(ctx, result)
+            try:
+                result_payload = self._serialize_output(output)
+                if self._max_result_bytes is not None and len(result_payload) > self._max_result_bytes:
+                    raise ValueError("result exceeds max size")
+                result_key = f"res:{req.job_id}"
+                await self._with_timeout(store.set(result_key, result_payload), "result write")
+                result_ptr = pointer_for_key(result_key)
+            except Exception as exc:
+                await self._publish_failure(ctx, req, f"result write failed: {exc}", execution_ms=elapsed_ms)
+                return
+
+            self._metrics.on_job_completed(req.job_id, elapsed_ms, "SUCCEEDED")
+            result = job_pb2.JobResult(
+                job_id=req.job_id,
+                status=job_pb2.JOB_STATUS_SUCCEEDED,
+                result_ptr=result_ptr,
+                worker_id=self._sender_id,
+                execution_ms=elapsed_ms,
+            )
+            await self._publish_result(ctx, result)
+        finally:
+            self._active_jobs.discard(req.job_id)
 
     def _validate_input(self, spec: HandlerSpec, data: Any) -> Any:
         if spec.input_model is None:

{cap_sdk_python-2.5.3 → cap_sdk_python-2.5.4}/cap_sdk_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cap-sdk-python
-Version: 2.5.3
+Version: 2.5.4
 Summary: CAP (Cordum Agent Protocol) Python SDK
 Author-email: Cordum <eng@cordum.io>
 License-Expression: Apache-2.0

{cap_sdk_python-2.5.3 → cap_sdk_python-2.5.4}/cap_sdk_python.egg-info/SOURCES.txt

@@ -4,8 +4,10 @@ cap/__init__.py
 cap/bus.py
 cap/client.py
 cap/errors.py
+cap/heartbeat.py
 cap/metrics.py
 cap/middleware.py
+cap/progress.py
 cap/runtime.py
 cap/subjects.py
 cap/testing.py
@@ -34,8 +36,10 @@ cap_sdk_python.egg-info/requires.txt
 cap_sdk_python.egg-info/top_level.txt
 tests/test_conformance.py
 tests/test_errors.py
+tests/test_heartbeat.py
 tests/test_metrics.py
 tests/test_middleware.py
+tests/test_progress.py
 tests/test_runtime.py
 tests/test_sdk.py
 tests/test_testing.py

{cap_sdk_python-2.5.3 → cap_sdk_python-2.5.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cap-sdk-python"
-version = "2.5.3"
+version = "2.5.4"
 description = "CAP (Cordum Agent Protocol) Python SDK"
 readme = "README.md"
 requires-python = ">=3.9"