Add option for gzip

Author: Sushisource

temporalio/bridge/client.py

@@ -81,6 +81,7 @@ class ClientConfig:
     client_version: str
     http_connect_proxy_config: ClientHttpConnectProxyConfig | None
     dns_load_balancing_config: ClientDnsLoadBalancingConfig | None
+    grpc_compression: str
 
 
 @dataclass

temporalio/bridge/src/client.rs

@@ -9,7 +9,7 @@ use temporalio_client::tonic::{
 };
 use temporalio_client::{
     ClientKeepAliveOptions as CoreClientKeepAliveConfig, Connection, ConnectionOptions,
-    DnsLoadBalancingOptions, HttpConnectProxyOptions, RetryOptions,
+    DnsLoadBalancingOptions, GrpcCompression, HttpConnectProxyOptions, RetryOptions,
 };
 use tracing::warn;
 use url::Url;
@@ -37,6 +37,7 @@ pub struct ClientConfig {
     keep_alive_config: Option<ClientKeepAliveConfig>,
     http_connect_proxy_config: Option<ClientHttpConnectProxyConfig>,
     dns_load_balancing_config: Option<ClientDnsLoadBalancingConfig>,
+    grpc_compression: String,
 }
 
 #[derive(FromPyObject)]
@@ -266,6 +267,7 @@ impl ClientConfig {
         .keep_alive(self.keep_alive_config.map(Into::into))
         .maybe_http_connect_proxy(self.http_connect_proxy_config.map(Into::into))
         .dns_load_balancing(dns_load_balancing)
+        .grpc_compression(grpc_compression_from_str(&self.grpc_compression)?)
         .headers(ascii_headers)
         .binary_headers(binary_headers)
         .maybe_api_key(self.api_key)
@@ -279,6 +281,16 @@ impl ClientConfig {
     }
 }
 
+fn grpc_compression_from_str(value: &str) -> PyResult<GrpcCompression> {
+    match value {
+        "none" => Ok(GrpcCompression::None),
+        "gzip" => Ok(GrpcCompression::Gzip),
+        _ => Err(PyValueError::new_err(format!(
+            "invalid grpc_compression: {value}"
+        ))),
+    }
+}
+
 impl TryFrom<ClientTlsConfig> for temporalio_client::TlsOptions {
     type Error = PyErr;
 

temporalio/client/__init__.py

@@ -16,6 +16,7 @@
 from temporalio.service import (
     ConnectConfig,
     DnsLoadBalancingConfig,
+    GrpcCompression,
     HttpConnectProxyConfig,
     KeepAliveConfig,
     RetryConfig,
@@ -355,6 +356,7 @@
     "WorkflowSerializationContext",
     "ConnectConfig",
     "DnsLoadBalancingConfig",
+    "GrpcCompression",
     "HttpConnectProxyConfig",
     "KeepAliveConfig",
     "RetryConfig",

temporalio/client/_client.py

@@ -32,6 +32,7 @@
 from temporalio.service import (
     ConnectConfig,
     DnsLoadBalancingConfig,
+    GrpcCompression,
     HttpConnectProxyConfig,
     KeepAliveConfig,
     RetryConfig,
@@ -152,6 +153,7 @@ async def connect(
         runtime: temporalio.runtime.Runtime | None = None,
         http_connect_proxy_config: HttpConnectProxyConfig | None = None,
         dns_load_balancing_config: DnsLoadBalancingConfig | None = None,
+        grpc_compression: GrpcCompression = GrpcCompression.GZIP,
         header_codec_behavior: HeaderCodecBehavior = HeaderCodecBehavior.NO_CODEC,
     ) -> Self:
         """Connect to a Temporal server.
@@ -212,6 +214,9 @@ async def connect(
                 be set to ``None`` to disable. Silently disabled when
                 ``http_connect_proxy_config`` is set, since the two are mutually
                 exclusive.
+            grpc_compression: Transport-level gRPC compression for the client
+                connection. Default is gzip. Set to
+                :py:attr:`GrpcCompression.NONE` to disable compression.
             header_codec_behavior: Encoding behavior for headers sent by the client.
         """
         connect_config = temporalio.service.ConnectConfig(
@@ -226,6 +231,7 @@ async def connect(
             runtime=runtime,
             http_connect_proxy_config=http_connect_proxy_config,
             dns_load_balancing_config=dns_load_balancing_config,
+            grpc_compression=grpc_compression,
         )
 
         def make_lambda(
@@ -3042,6 +3048,7 @@ class ClientConnectConfig(TypedDict, total=False):
     runtime: temporalio.runtime.Runtime | None
     http_connect_proxy_config: HttpConnectProxyConfig | None
     dns_load_balancing_config: DnsLoadBalancingConfig | None
+    grpc_compression: GrpcCompression
     header_codec_behavior: HeaderCodecBehavior
 
 

temporalio/client/_cloud.py

@@ -10,6 +10,7 @@
 import temporalio.service
 from temporalio.service import (
     DnsLoadBalancingConfig,
+    GrpcCompression,
     HttpConnectProxyConfig,
     KeepAliveConfig,
     RetryConfig,
@@ -51,6 +52,7 @@ async def connect(
         runtime: temporalio.runtime.Runtime | None = None,
         http_connect_proxy_config: HttpConnectProxyConfig | None = None,
         dns_load_balancing_config: DnsLoadBalancingConfig | None = None,
+        grpc_compression: GrpcCompression = GrpcCompression.GZIP,
     ) -> CloudOperationsClient:
         """Connect to a Temporal Cloud Operations API.
 
@@ -91,6 +93,9 @@ async def connect(
                 client connection. Default is disabled. Silently disabled when
                 ``http_connect_proxy_config`` is set, since the two are mutually
                 exclusive.
+            grpc_compression: Transport-level gRPC compression for the client
+                connection. Default is gzip. Set to
+                :py:attr:`GrpcCompression.NONE` to disable compression.
         """
         # Add version if given
         if version:
@@ -108,6 +113,7 @@ async def connect(
             runtime=runtime,
             http_connect_proxy_config=http_connect_proxy_config,
             dns_load_balancing_config=dns_load_balancing_config,
+            grpc_compression=grpc_compression,
         )
         return CloudOperationsClient(
             await temporalio.service.ServiceClient.connect(connect_config)

temporalio/service.py

@@ -11,7 +11,7 @@
 from collections.abc import Mapping
 from dataclasses import dataclass, field
 from datetime import timedelta
-from enum import IntEnum
+from enum import Enum, IntEnum
 from typing import ClassVar, TypeVar
 
 import google.protobuf.message
@@ -158,6 +158,16 @@ def _to_bridge_config(
 DnsLoadBalancingConfig.default = DnsLoadBalancingConfig()
 
 
+class GrpcCompression(Enum):
+    """Transport-level gRPC compression mode."""
+
+    NONE = "none"
+    """Do not compress gRPC requests or advertise support for compressed responses."""
+
+    GZIP = "gzip"
+    """Gzip-compress gRPC requests and accept gzip-compressed responses."""
+
+
 @dataclass
 class ConnectConfig:
     """Config for connecting to the server."""
@@ -173,6 +183,7 @@ class ConnectConfig:
     runtime: temporalio.runtime.Runtime | None = None
     http_connect_proxy_config: HttpConnectProxyConfig | None = None
     dns_load_balancing_config: DnsLoadBalancingConfig | None = None
+    grpc_compression: GrpcCompression = GrpcCompression.GZIP
 
     def __post_init__(self) -> None:
         """Set extra defaults on unset properties."""
@@ -235,6 +246,7 @@ def _to_bridge_config(self) -> temporalio.bridge.client.ClientConfig:
                 if self.dns_load_balancing_config
                 else None
             ),
+            grpc_compression=self.grpc_compression.value,
         )
 
 

tests/test_client_exports.py

@@ -51,6 +51,7 @@
     "FetchWorkflowHistoryEventsInput",
     "GetWorkerBuildIdCompatibilityInput",
     "GetWorkerTaskReachabilityInput",
+    "GrpcCompression",
     "HeaderCodecBehavior",
     "HeartbeatAsyncActivityInput",
     "HttpConnectProxyConfig",

tests/test_service.py

@@ -242,6 +242,24 @@ def test_connect_config_dns_load_balancing_disabled():
     assert bridge_config.dns_load_balancing_config is None
 
 
+def test_connect_config_grpc_compression_default():
+    """gRPC compression defaults to gzip and is forwarded to the bridge."""
+    config = temporalio.service.ConnectConfig(target_host="localhost:7233")
+    bridge_config = config._to_bridge_config()
+    assert config.grpc_compression == temporalio.service.GrpcCompression.GZIP
+    assert bridge_config.grpc_compression == "gzip"
+
+
+def test_connect_config_grpc_compression_none():
+    """gRPC compression can be disabled and is forwarded to the bridge."""
+    config = temporalio.service.ConnectConfig(
+        target_host="localhost:7233",
+        grpc_compression=temporalio.service.GrpcCompression.NONE,
+    )
+    bridge_config = config._to_bridge_config()
+    assert bridge_config.grpc_compression == "none"
+
+
 async def test_rpc_execution_not_unknown(client: Client):
     """
     Execute each rpc method and expect a failure, but ensure the failure is not that the rpc method is unknown