cadence-python-client 0.1.0__py3-none-any.whl

cadence/metrics/constants.py

@@ -0,0 +1,136 @@
+"""Metric name constants for Cadence client matching Go client naming convention."""
+
+# Metric name prefix
+CADENCE_METRICS_PREFIX = "cadence-"
+
+# Workflow Creation metrics
+WORKFLOW_START_COUNTER = CADENCE_METRICS_PREFIX + "workflow-start"
+WORKFLOW_START_ASYNC_COUNTER = CADENCE_METRICS_PREFIX + "workflow-start-async"
+WORKFLOW_COMPLETED_COUNTER = CADENCE_METRICS_PREFIX + "workflow-completed"
+WORKFLOW_CANCELED_COUNTER = CADENCE_METRICS_PREFIX + "workflow-canceled"
+WORKFLOW_FAILED_COUNTER = CADENCE_METRICS_PREFIX + "workflow-failed"
+WORKFLOW_CONTINUE_AS_NEW_COUNTER = CADENCE_METRICS_PREFIX + "workflow-continue-as-new"
+WORKFLOW_END_TO_END_LATENCY = CADENCE_METRICS_PREFIX + "workflow-endtoend-latency"
+WORKFLOW_GET_HISTORY_COUNTER = CADENCE_METRICS_PREFIX + "workflow-get-history-total"
+WORKFLOW_GET_HISTORY_FAILED_COUNTER = (
+    CADENCE_METRICS_PREFIX + "workflow-get-history-failed"
+)
+WORKFLOW_GET_HISTORY_SUCCEED_COUNTER = (
+    CADENCE_METRICS_PREFIX + "workflow-get-history-succeed"
+)
+WORKFLOW_GET_HISTORY_LATENCY = CADENCE_METRICS_PREFIX + "workflow-get-history-latency"
+WORKFLOW_SIGNAL_WITH_START_COUNTER = (
+    CADENCE_METRICS_PREFIX + "workflow-signal-with-start"
+)
+WORKFLOW_SIGNAL_WITH_START_ASYNC_COUNTER = (
+    CADENCE_METRICS_PREFIX + "workflow-signal-with-start-async"
+)
+DECISION_TIMEOUT_COUNTER = CADENCE_METRICS_PREFIX + "decision-timeout"
+
+# Decision Poll metrics
+DECISION_POLL_COUNTER = CADENCE_METRICS_PREFIX + "decision-poll-total"
+DECISION_POLL_FAILED_COUNTER = CADENCE_METRICS_PREFIX + "decision-poll-failed"
+DECISION_POLL_TRANSIENT_FAILED_COUNTER = (
+    CADENCE_METRICS_PREFIX + "decision-poll-transient-failed"
+)
+DECISION_POLL_NO_TASK_COUNTER = CADENCE_METRICS_PREFIX + "decision-poll-no-task"
+DECISION_POLL_SUCCEED_COUNTER = CADENCE_METRICS_PREFIX + "decision-poll-succeed"
+DECISION_POLL_LATENCY = CADENCE_METRICS_PREFIX + "decision-poll-latency"
+DECISION_POLL_INVALID_COUNTER = CADENCE_METRICS_PREFIX + "decision-poll-invalid"
+DECISION_SCHEDULED_TO_START_LATENCY = (
+    CADENCE_METRICS_PREFIX + "decision-scheduled-to-start-latency"
+)
+DECISION_EXECUTION_FAILED_COUNTER = CADENCE_METRICS_PREFIX + "decision-execution-failed"
+DECISION_EXECUTION_LATENCY = CADENCE_METRICS_PREFIX + "decision-execution-latency"
+DECISION_RESPONSE_FAILED_COUNTER = CADENCE_METRICS_PREFIX + "decision-response-failed"
+DECISION_RESPONSE_LATENCY = CADENCE_METRICS_PREFIX + "decision-response-latency"
+DECISION_TASK_PANIC_COUNTER = CADENCE_METRICS_PREFIX + "decision-task-panic"
+DECISION_TASK_COMPLETED_COUNTER = CADENCE_METRICS_PREFIX + "decision-task-completed"
+DECISION_TASK_FORCE_COMPLETED_COUNTER = (
+    CADENCE_METRICS_PREFIX + "decision-task-force-completed"
+)
+
+# Activity Poll metrics
+ACTIVITY_POLL_COUNTER = CADENCE_METRICS_PREFIX + "activity-poll-total"
+ACTIVITY_POLL_FAILED_COUNTER = CADENCE_METRICS_PREFIX + "activity-poll-failed"
+ACTIVITY_POLL_TRANSIENT_FAILED_COUNTER = (
+    CADENCE_METRICS_PREFIX + "activity-poll-transient-failed"
+)
+ACTIVITY_POLL_NO_TASK_COUNTER = CADENCE_METRICS_PREFIX + "activity-poll-no-task"
+ACTIVITY_POLL_SUCCEED_COUNTER = CADENCE_METRICS_PREFIX + "activity-poll-succeed"
+ACTIVITY_POLL_LATENCY = CADENCE_METRICS_PREFIX + "activity-poll-latency"
+ACTIVITY_SCHEDULED_TO_START_LATENCY = (
+    CADENCE_METRICS_PREFIX + "activity-scheduled-to-start-latency"
+)
+ACTIVITY_EXECUTION_FAILED_COUNTER = CADENCE_METRICS_PREFIX + "activity-execution-failed"
+ACTIVITY_EXECUTION_LATENCY = CADENCE_METRICS_PREFIX + "activity-execution-latency"
+ACTIVITY_RESPONSE_LATENCY = CADENCE_METRICS_PREFIX + "activity-response-latency"
+ACTIVITY_RESPONSE_FAILED_COUNTER = CADENCE_METRICS_PREFIX + "activity-response-failed"
+ACTIVITY_END_TO_END_LATENCY = CADENCE_METRICS_PREFIX + "activity-endtoend-latency"
+ACTIVITY_TASK_PANIC_COUNTER = CADENCE_METRICS_PREFIX + "activity-task-panic"
+ACTIVITY_TASK_COMPLETED_COUNTER = CADENCE_METRICS_PREFIX + "activity-task-completed"
+ACTIVITY_TASK_FAILED_COUNTER = CADENCE_METRICS_PREFIX + "activity-task-failed"
+ACTIVITY_TASK_CANCELED_COUNTER = CADENCE_METRICS_PREFIX + "activity-task-canceled"
+ACTIVITY_TASK_COMPLETED_BY_ID_COUNTER = (
+    CADENCE_METRICS_PREFIX + "activity-task-completed-by-id"
+)
+ACTIVITY_TASK_FAILED_BY_ID_COUNTER = (
+    CADENCE_METRICS_PREFIX + "activity-task-failed-by-id"
+)
+ACTIVITY_TASK_CANCELED_BY_ID_COUNTER = (
+    CADENCE_METRICS_PREFIX + "activity-task-canceled-by-id"
+)
+
+# Local Activity metrics
+LOCAL_ACTIVITY_TOTAL_COUNTER = CADENCE_METRICS_PREFIX + "local-activity-total"
+LOCAL_ACTIVITY_TIMEOUT_COUNTER = CADENCE_METRICS_PREFIX + "local-activity-timeout"
+LOCAL_ACTIVITY_CANCELED_COUNTER = CADENCE_METRICS_PREFIX + "local-activity-canceled"
+LOCAL_ACTIVITY_FAILED_COUNTER = CADENCE_METRICS_PREFIX + "local-activity-failed"
+LOCAL_ACTIVITY_PANIC_COUNTER = CADENCE_METRICS_PREFIX + "local-activity-panic"
+LOCAL_ACTIVITY_EXECUTION_LATENCY = (
+    CADENCE_METRICS_PREFIX + "local-activity-execution-latency"
+)
+LOCALLY_DISPATCHED_ACTIVITY_POLL_COUNTER = (
+    CADENCE_METRICS_PREFIX + "locally-dispatched-activity-poll-total"
+)
+LOCALLY_DISPATCHED_ACTIVITY_POLL_NO_TASK_COUNTER = (
+    CADENCE_METRICS_PREFIX + "locally-dispatched-activity-poll-no-task"
+)
+LOCALLY_DISPATCHED_ACTIVITY_POLL_SUCCEED_COUNTER = (
+    CADENCE_METRICS_PREFIX + "locally-dispatched-activity-poll-succeed"
+)
+ACTIVITY_LOCAL_DISPATCH_FAILED_COUNTER = (
+    CADENCE_METRICS_PREFIX + "activity-local-dispatch-failed"
+)
+ACTIVITY_LOCAL_DISPATCH_SUCCEED_COUNTER = (
+    CADENCE_METRICS_PREFIX + "activity-local-dispatch-succeed"
+)
+WORKER_PANIC_COUNTER = CADENCE_METRICS_PREFIX + "worker-panic"
+
+# Signal metrics
+UNHANDLED_SIGNALS_COUNTER = CADENCE_METRICS_PREFIX + "unhandled-signals"
+CORRUPTED_SIGNALS_COUNTER = CADENCE_METRICS_PREFIX + "corrupted-signals"
+
+# Worker metrics
+WORKER_START_COUNTER = CADENCE_METRICS_PREFIX + "worker-start"
+POLLER_START_COUNTER = CADENCE_METRICS_PREFIX + "poller-start"
+
+# Client metrics
+CADENCE_REQUEST = CADENCE_METRICS_PREFIX + "request"
+CADENCE_ERROR = CADENCE_METRICS_PREFIX + "error"
+CADENCE_LATENCY = CADENCE_METRICS_PREFIX + "latency"
+CADENCE_INVALID_REQUEST = CADENCE_METRICS_PREFIX + "invalid-request"
+
+# Sticky Cache metrics
+STICKY_CACHE_HIT = CADENCE_METRICS_PREFIX + "sticky-cache-hit"
+STICKY_CACHE_MISS = CADENCE_METRICS_PREFIX + "sticky-cache-miss"
+STICKY_CACHE_EVICT = CADENCE_METRICS_PREFIX + "sticky-cache-evict"
+STICKY_CACHE_STALL = CADENCE_METRICS_PREFIX + "sticky-cache-stall"
+STICKY_CACHE_SIZE = CADENCE_METRICS_PREFIX + "sticky-cache-size"
+
+# Replay metrics
+NON_DETERMINISTIC_ERROR = CADENCE_METRICS_PREFIX + "non-deterministic-error"
+REPLAY_SUCCEED_COUNTER = CADENCE_METRICS_PREFIX + "replay-succeed"
+REPLAY_FAILED_COUNTER = CADENCE_METRICS_PREFIX + "replay-failed"
+REPLAY_SKIPPED_COUNTER = CADENCE_METRICS_PREFIX + "replay-skipped"
+REPLAY_LATENCY = CADENCE_METRICS_PREFIX + "replay-latency"

cadence/metrics/metrics.py

@@ -0,0 +1,56 @@
+"""Core metrics collection interface and registry for Cadence client."""
+
+import logging
+from enum import Enum
+from typing import Dict, Optional, Protocol
+
+logger = logging.getLogger(__name__)
+
+
+class MetricType(Enum):
+    """Types of metrics that can be collected."""
+
+    COUNTER = "counter"
+    GAUGE = "gauge"
+    HISTOGRAM = "histogram"
+
+
+class MetricsEmitter(Protocol):
+    """Protocol for metrics collection backends."""
+
+    def counter(
+        self, key: str, n: int = 1, tags: Optional[Dict[str, str]] = None
+    ) -> None:
+        """Send a counter metric."""
+        ...
+
+    def gauge(
+        self, key: str, value: float, tags: Optional[Dict[str, str]] = None
+    ) -> None:
+        """Send a gauge metric."""
+        ...
+
+    def histogram(
+        self, key: str, value: float, tags: Optional[Dict[str, str]] = None
+    ) -> None:
+        """Send a histogram metric."""
+        ...
+
+
+class NoOpMetricsEmitter:
+    """No-op metrics emitter that discards all metrics."""
+
+    def counter(
+        self, key: str, n: int = 1, tags: Optional[Dict[str, str]] = None
+    ) -> None:
+        pass
+
+    def gauge(
+        self, key: str, value: float, tags: Optional[Dict[str, str]] = None
+    ) -> None:
+        pass
+
+    def histogram(
+        self, key: str, value: float, tags: Optional[Dict[str, str]] = None
+    ) -> None:
+        pass

cadence/metrics/prometheus.py

@@ -0,0 +1,165 @@
+"""Prometheus metrics integration for Cadence client."""
+
+import logging
+from dataclasses import dataclass, field
+from typing import Dict, Optional
+
+from prometheus_client import (  # type: ignore[import-not-found]
+    REGISTRY,
+    CollectorRegistry,
+    Counter,
+    Gauge,
+    Histogram,
+    generate_latest,
+)
+
+from .metrics import MetricsEmitter
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class PrometheusConfig:
+    """Configuration for Prometheus metrics."""
+
+    # Default labels to apply to all metrics
+    default_labels: Dict[str, str] = field(default_factory=dict)
+
+    # Custom registry (if None, uses default global registry)
+    registry: Optional[CollectorRegistry] = None
+
+
+class PrometheusMetrics(MetricsEmitter):
+    """Prometheus metrics collector implementation."""
+
+    def __init__(self, config: Optional[PrometheusConfig] = None):
+        self.config = config or PrometheusConfig()
+        self.registry = self.config.registry or REGISTRY
+
+        # Track created metrics to avoid duplicates
+        self._counters: Dict[str, Counter] = {}
+        self._gauges: Dict[str, Gauge] = {}
+        self._histograms: Dict[str, Histogram] = {}
+
+    def _get_metric_name(self, name: str) -> str:
+        """Get the metric name."""
+        return name
+
+    def _merge_labels(self, labels: Optional[Dict[str, str]]) -> Dict[str, str]:
+        """Merge provided labels with default labels."""
+        merged = self.config.default_labels.copy()
+        if labels:
+            merged.update(labels)
+        return merged
+
+    def _get_or_create_counter(
+        self, name: str, labels: Optional[Dict[str, str]]
+    ) -> Counter:
+        """Get or create a Counter metric."""
+        metric_name = self._get_metric_name(name)
+
+        if metric_name not in self._counters:
+            label_names = list(self._merge_labels(labels).keys()) if labels else []
+            self._counters[metric_name] = Counter(
+                metric_name,
+                f"Counter metric for {name}",
+                labelnames=label_names,
+                registry=self.registry,
+            )
+            logger.debug(f"Created counter metric: {metric_name}")
+
+        return self._counters[metric_name]
+
+    def _get_or_create_gauge(
+        self, name: str, labels: Optional[Dict[str, str]]
+    ) -> Gauge:
+        """Get or create a Gauge metric."""
+        metric_name = self._get_metric_name(name)
+
+        if metric_name not in self._gauges:
+            label_names = list(self._merge_labels(labels).keys()) if labels else []
+            self._gauges[metric_name] = Gauge(
+                metric_name,
+                f"Gauge metric for {name}",
+                labelnames=label_names,
+                registry=self.registry,
+            )
+            logger.debug(f"Created gauge metric: {metric_name}")
+
+        return self._gauges[metric_name]
+
+    def _get_or_create_histogram(
+        self, name: str, labels: Optional[Dict[str, str]]
+    ) -> Histogram:
+        """Get or create a Histogram metric."""
+        metric_name = self._get_metric_name(name)
+
+        if metric_name not in self._histograms:
+            label_names = list(self._merge_labels(labels).keys()) if labels else []
+            self._histograms[metric_name] = Histogram(
+                metric_name,
+                f"Histogram metric for {name}",
+                labelnames=label_names,
+                registry=self.registry,
+            )
+            logger.debug(f"Created histogram metric: {metric_name}")
+
+        return self._histograms[metric_name]
+
+    def counter(
+        self, key: str, n: int = 1, tags: Optional[Dict[str, str]] = None
+    ) -> None:
+        """Send a counter metric."""
+        try:
+            counter = self._get_or_create_counter(key, tags)
+            merged_tags = self._merge_labels(tags)
+
+            if merged_tags:
+                counter.labels(**merged_tags).inc(n)
+            else:
+                counter.inc(n)
+
+        except Exception as e:
+            logger.error(f"Failed to send counter {key}: {e}")
+
+    def gauge(
+        self, key: str, value: float, tags: Optional[Dict[str, str]] = None
+    ) -> None:
+        """Send a gauge metric."""
+        try:
+            gauge = self._get_or_create_gauge(key, tags)
+            merged_tags = self._merge_labels(tags)
+
+            if merged_tags:
+                gauge.labels(**merged_tags).set(value)
+            else:
+                gauge.set(value)
+
+        except Exception as e:
+            logger.error(f"Failed to send gauge {key}: {e}")
+
+    def histogram(
+        self, key: str, value: float, tags: Optional[Dict[str, str]] = None
+    ) -> None:
+        """Send a histogram metric."""
+        try:
+            histogram = self._get_or_create_histogram(key, tags)
+            merged_tags = self._merge_labels(tags)
+
+            if merged_tags:
+                histogram.labels(**merged_tags).observe(value)
+            else:
+                histogram.observe(value)
+
+        except Exception as e:
+            logger.error(f"Failed to send histogram {key}: {e}")
+
+    def get_metrics_text(self) -> str:
+        """Get metrics in Prometheus text format."""
+        try:
+            metrics_bytes = generate_latest(self.registry)
+            return metrics_bytes.decode("utf-8")  # type: ignore[no-any-return]
+        except Exception as e:
+            logger.error(f"Failed to generate metrics text: {e}")
+            return ""

cadence/sample/__init__.py

@@ -0,0 +1 @@
+# Sample directory for cadence protobuf import tests

cadence/sample/client_example.py

@@ -0,0 +1,15 @@
+import asyncio
+
+
+from cadence.client import Client
+from cadence.worker import Worker, Registry
+
+
+async def main():
+    async with Client(target="localhost:7833", domain="foo") as client:
+        worker = Worker(client, "task_list", Registry())
+        await worker.run()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

cadence/sample/grpc_usage_example.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""
+Example demonstrating how to use the generated gRPC code for Cadence services.
+This example shows how to create a gRPC client and make calls to Cadence workflow services.
+"""
+
+import grpc
+from cadence.api.v1 import service_workflow_grpc, service_workflow, common
+
+
+def create_grpc_channel(
+    server_address: str = "localhost:7833", use_ssl: bool = False
+) -> grpc.Channel:
+    """
+    Create a gRPC channel to connect to Cadence server.
+
+    Args:
+        server_address: The address of the Cadence server (host:port)
+        use_ssl: Whether to use SSL/TLS for the connection
+
+    Returns:
+        grpc.Channel: The gRPC channel
+    """
+    if use_ssl:
+        # For SSL connections, you would typically use credentials
+        credentials = grpc.ssl_channel_credentials()
+        return grpc.secure_channel(server_address, credentials)
+    else:
+        # For insecure connections (development)
+        return grpc.insecure_channel(server_address)
+
+
+def create_workflow_client(
+    channel: grpc.Channel,
+) -> service_workflow_grpc.WorkflowAPIStub:
+    """
+    Create a gRPC client for the WorkflowAPI service.
+
+    Args:
+        channel: The gRPC channel
+
+    Returns:
+        WorkflowAPIStub: The gRPC client stub
+    """
+    return service_workflow_grpc.WorkflowAPIStub(channel)
+
+
+def example_start_workflow(
+    client: service_workflow_grpc.WorkflowAPIStub, domain: str, workflow_id: str
+):
+    """
+    Example of starting a workflow execution using gRPC.
+
+    Args:
+        client: The gRPC client
+        domain: The Cadence domain
+        workflow_id: The workflow ID
+    """
+    # Create the request message
+    request = service_workflow.StartWorkflowExecutionRequest()
+    request.domain = domain
+    request.workflow_id = workflow_id
+    request.workflow_type.name = "MyWorkflow"
+    request.task_list.name = "my-task-list"
+    request.input.data = b"workflow input data"  # Serialized workflow input
+    request.execution_start_to_close_timeout.seconds = 3600  # 1 hour
+    request.task_start_to_close_timeout.seconds = 60  # 1 minute
+    request.identity = "python-client"
+
+    try:
+        # Make the gRPC call
+        response = client.StartWorkflowExecution(request)
+        print(f"✓ Workflow started successfully: {response}")
+        return response
+    except grpc.RpcError as e:
+        print(f"✗ Failed to start workflow: {e}")
+        return None
+
+
+def example_describe_workflow(
+    client: service_workflow_grpc.WorkflowAPIStub,
+    domain: str,
+    workflow_id: str,
+    run_id: str,
+):
+    """
+    Example of describing a workflow execution using gRPC.
+
+    Args:
+        client: The gRPC client
+        domain: The Cadence domain
+        workflow_id: The workflow ID
+        run_id: The workflow run ID
+    """
+    # Create the request message
+    request = service_workflow.DescribeWorkflowExecutionRequest()
+    request.domain = domain
+    execution = common.WorkflowExecution()
+    execution.workflow_id = workflow_id
+    execution.run_id = run_id
+    request.workflow_execution.CopyFrom(execution)
+
+    try:
+        # Make the gRPC call
+        response = client.DescribeWorkflowExecution(request)
+        print(f"✓ Workflow description: {response}")
+        return response
+    except grpc.RpcError as e:
+        print(f"✗ Failed to describe workflow: {e}")
+        return None
+
+
+def example_get_workflow_history(
+    client: service_workflow_grpc.WorkflowAPIStub,
+    domain: str,
+    workflow_id: str,
+    run_id: str,
+):
+    """
+    Example of getting workflow execution history using gRPC.
+
+    Args:
+        client: The gRPC client
+        domain: The Cadence domain
+        workflow_id: The workflow ID
+        run_id: The workflow run ID
+    """
+    # Create the request message
+    request = service_workflow.GetWorkflowExecutionHistoryRequest()
+    request.domain = domain
+    execution = common.WorkflowExecution()
+    execution.workflow_id = workflow_id
+    execution.run_id = run_id
+    request.workflow_execution.CopyFrom(execution)
+    request.page_size = 100
+
+    try:
+        # Make the gRPC call
+        response = client.GetWorkflowExecutionHistory(request)
+        print(f"✓ Workflow history retrieved: {len(response.history.events)} events")
+        return response
+    except grpc.RpcError as e:
+        print(f"✗ Failed to get workflow history: {e}")
+        return None
+
+
+def example_query_workflow(
+    client: service_workflow_grpc.WorkflowAPIStub,
+    domain: str,
+    workflow_id: str,
+    run_id: str,
+    query_type: str,
+):
+    """
+    Example of querying a workflow using gRPC.
+
+    Args:
+        client: The gRPC client
+        domain: The Cadence domain
+        workflow_id: The workflow ID
+        run_id: The workflow run ID
+        query_type: The type of query to execute
+    """
+    # Create the request message
+    request = service_workflow.QueryWorkflowRequest()
+    request.domain = domain
+    execution = common.WorkflowExecution()
+    execution.workflow_id = workflow_id
+    execution.run_id = run_id
+    request.workflow_execution.CopyFrom(execution)
+    request.query.query_type = query_type
+    request.query.query_args.data = b"query arguments"  # Serialized query arguments
+
+    try:
+        # Make the gRPC call
+        response = client.QueryWorkflow(request)
+        print(f"✓ Workflow query result: {response}")
+        return response
+    except grpc.RpcError as e:
+        print(f"✗ Failed to query workflow: {e}")
+        return None
+
+
+def main():
+    """Main example function."""
+    print("Cadence gRPC Client Example")
+    print("=" * 40)
+
+    # Configuration
+    server_address = "localhost:7833"  # Default Cadence gRPC port
+    domain = "test-domain"
+    workflow_id = "example-workflow-123"
+    run_id = "example-run-456"
+
+    try:
+        # Create gRPC channel
+        print(f"Connecting to Cadence server at {server_address}...")
+        channel = create_grpc_channel(server_address)
+
+        # Create gRPC client
+        client = create_workflow_client(channel)
+        print("✓ gRPC client created successfully")
+
+        # Example 1: Start a workflow
+        print("\n1. Starting a workflow...")
+        example_start_workflow(client, domain, workflow_id)
+
+        # Example 2: Describe a workflow
+        print("\n2. Describing a workflow...")
+        example_describe_workflow(client, domain, workflow_id, run_id)
+
+        # Example 3: Get workflow history
+        print("\n3. Getting workflow history...")
+        example_get_workflow_history(client, domain, workflow_id, run_id)
+
+        # Example 4: Query a workflow
+        print("\n4. Querying a workflow...")
+        example_query_workflow(client, domain, workflow_id, run_id, "status")
+
+    except Exception as e:
+        print(f"✗ Error: {e}")
+    finally:
+        # Close the channel
+        if "channel" in locals():
+            channel.close()
+            print("\n✓ gRPC channel closed")
+
+
+if __name__ == "__main__":
+    main()