refactor: remove underscore prefix from gapic client helpers

Author: hebaalazzeh

packages/google-api-core/google/api_core/gapic_v1/client_helpers.py

@@ -30,7 +30,7 @@
 )
 
 
-def _get_default_mtls_endpoint(api_endpoint: Optional[str]) -> Optional[str]:
+def get_default_mtls_endpoint(api_endpoint: Optional[str]) -> Optional[str]:
     """Converts api endpoint to mTLS endpoint.
 
     Convert "*.sandbox.googleapis.com" and "*.googleapis.com" to
@@ -60,7 +60,7 @@ def _get_default_mtls_endpoint(api_endpoint: Optional[str]) -> Optional[str]:
     return api_endpoint.replace(".googleapis.com", ".mtls.googleapis.com")
 
 
-def _use_client_cert_effective() -> bool:
+def use_client_cert_effective() -> bool:
     """Returns whether client certificate should be used for mTLS if the
     google-auth version supports should_use_client_cert automatic mTLS
     enablement.
@@ -91,7 +91,7 @@ def _use_client_cert_effective() -> bool:
         return use_client_cert_str == "true"
 
 
-def _get_api_endpoint(
+def get_api_endpoint(
     api_override: Optional[str],
     client_cert_source: Optional[Any],
     universe_domain: str,
@@ -126,10 +126,12 @@ def _get_api_endpoint(
             )
         return default_mtls_endpoint
     else:
-        return default_endpoint_template.format(UNIVERSE_DOMAIN=universe_domain)
+        return default_endpoint_template.format(
+            UNIVERSE_DOMAIN=universe_domain
+        )
 
 
-def _read_environment_variables() -> Tuple[bool, str, Optional[str]]:
+def read_environment_variables() -> Tuple[bool, str, Optional[str]]:
     """Returns the environment variables used by the client.
 
     Returns:
@@ -144,8 +146,10 @@ def _read_environment_variables() -> Tuple[bool, str, Optional[str]]:
             GOOGLE_API_USE_MTLS_ENDPOINT is not any of
             ["auto", "never", "always"].
     """
-    use_client_cert = _use_client_cert_effective()
-    use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto").lower()
+    use_client_cert = use_client_cert_effective()
+    use_mtls_endpoint = os.getenv(
+        "GOOGLE_API_USE_MTLS_ENDPOINT", "auto"
+    ).lower()
     universe_domain_env = os.getenv("GOOGLE_CLOUD_UNIVERSE_DOMAIN")
     if use_mtls_endpoint not in ("auto", "never", "always"):
         raise MutualTLSChannelError(
@@ -155,7 +159,7 @@ def _read_environment_variables() -> Tuple[bool, str, Optional[str]]:
     return use_client_cert, use_mtls_endpoint, universe_domain_env
 
 
-def _get_client_cert_source(
+def get_client_cert_source(
     provided_cert_source: Optional[Any], use_cert_flag: bool
 ) -> Optional[Any]:
     """Return the client cert source to be used by the client.
@@ -180,7 +184,7 @@ def _get_client_cert_source(
     return client_cert_source
 
 
-def _get_universe_domain(
+def get_universe_domain(
     client_universe_domain: Optional[str],
     universe_domain_env: Optional[str],
     default_universe: str,
@@ -210,7 +214,9 @@ def _get_universe_domain(
     return universe_domain
 
 
-def _setup_request_id(request: Any, field_name: str, is_proto3_optional: bool) -> None:
+def setup_request_id(
+    request: Any, field_name: str, is_proto3_optional: bool
+) -> None:
     """Populate a UUID4 field in the request if it is not already set.
 
     Args:

packages/google-api-core/tests/unit/gapic/test_client_helpers.py

@@ -21,69 +21,69 @@
 from google.auth.exceptions import MutualTLSChannelError
 
 
-def test__get_default_mtls_endpoint():
+def test_get_default_mtls_endpoint():
     # Test valid API endpoints
     assert (
-        client_helpers._get_default_mtls_endpoint("foo.googleapis.com")
+        client_helpers.get_default_mtls_endpoint("foo.googleapis.com")
         == "foo.mtls.googleapis.com"
     )
     assert (
-        client_helpers._get_default_mtls_endpoint("foo.sandbox.googleapis.com")
+        client_helpers.get_default_mtls_endpoint("foo.sandbox.googleapis.com")
         == "foo.mtls.sandbox.googleapis.com"
     )
 
     # Test endpoints that shouldn't be converted
     assert (
-        client_helpers._get_default_mtls_endpoint("foo.mtls.googleapis.com")
+        client_helpers.get_default_mtls_endpoint("foo.mtls.googleapis.com")
         == "foo.mtls.googleapis.com"
     )
-    assert client_helpers._get_default_mtls_endpoint("foo.com") == "foo.com"
+    assert client_helpers.get_default_mtls_endpoint("foo.com") == "foo.com"
 
     # Test empty/None endpoints
-    assert client_helpers._get_default_mtls_endpoint("") == ""
-    assert client_helpers._get_default_mtls_endpoint(None) is None
+    assert client_helpers.get_default_mtls_endpoint("") == ""
+    assert client_helpers.get_default_mtls_endpoint(None) is None
 
 
 @mock.patch("google.auth.transport.mtls.should_use_client_cert", autospec=True)
-def test__use_client_cert_effective_with_google_auth(mock_method):
+def test_use_client_cert_effective_with_google_auth(mock_method):
     # Test when google-auth supports the method
     mock_method.return_value = True
-    assert client_helpers._use_client_cert_effective() is True
+    assert client_helpers.use_client_cert_effective() is True
 
     mock_method.return_value = False
-    assert client_helpers._use_client_cert_effective() is False
+    assert client_helpers.use_client_cert_effective() is False
 
 
 @mock.patch.dict(os.environ, {}, clear=True)
-def test__use_client_cert_effective_fallback():
+def test_use_client_cert_effective_fallback():
     # We must patch hasattr to simulate google-auth lacking the method
     with mock.patch(
         "google.api_core.gapic_v1.client_helpers.hasattr", return_value=False
     ):
         # Default is false
-        assert client_helpers._use_client_cert_effective() is False
+        assert client_helpers.use_client_cert_effective() is False
 
         env_true = {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "true"}
         with mock.patch.dict(os.environ, env_true):
-            assert client_helpers._use_client_cert_effective() is True
+            assert client_helpers.use_client_cert_effective() is True
 
         with mock.patch.dict(
             os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "false"}
         ):
-            assert client_helpers._use_client_cert_effective() is False
+            assert client_helpers.use_client_cert_effective() is False
 
         with mock.patch.dict(
             os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "invalid"}
         ):
             match_str = "must be either `true` or `false`"
             with pytest.raises(ValueError, match=match_str):
-                client_helpers._use_client_cert_effective()
+                client_helpers.use_client_cert_effective()
 
 
-def test__get_api_endpoint_override():
+def test_get_api_endpoint_override():
     # If api_override is provided, it should be returned
     # regardless of other args
-    endpoint = client_helpers._get_api_endpoint(
+    endpoint = client_helpers.get_api_endpoint(
         api_override="custom.endpoint.com",
         client_cert_source=None,
         universe_domain="googleapis.com",
@@ -95,9 +95,9 @@ def test__get_api_endpoint_override():
     assert endpoint == "custom.endpoint.com"
 
 
-def test__get_api_endpoint_mtls_always():
+def test_get_api_endpoint_mtls_always():
     # use_mtls_endpoint == "always" should use the default mtls endpoint
-    endpoint = client_helpers._get_api_endpoint(
+    endpoint = client_helpers.get_api_endpoint(
         api_override=None,
         client_cert_source=None,
         universe_domain="googleapis.com",
@@ -109,9 +109,9 @@ def test__get_api_endpoint_mtls_always():
     assert endpoint == "foo.mtls.googleapis.com"
 
 
-def test__get_api_endpoint_mtls_auto_with_cert():
+def test_get_api_endpoint_mtls_auto_with_cert():
     # "auto" with client_cert_source should use mtls
-    endpoint = client_helpers._get_api_endpoint(
+    endpoint = client_helpers.get_api_endpoint(
         api_override=None,
         client_cert_source=mock.Mock(),
         universe_domain="googleapis.com",
@@ -123,9 +123,9 @@ def test__get_api_endpoint_mtls_auto_with_cert():
     assert endpoint == "foo.mtls.googleapis.com"
 
 
-def test__get_api_endpoint_mtls_auto_no_cert():
+def test_get_api_endpoint_mtls_auto_no_cert():
     # "auto" without client_cert_source should use the default template
-    endpoint = client_helpers._get_api_endpoint(
+    endpoint = client_helpers.get_api_endpoint(
         api_override=None,
         client_cert_source=None,
         universe_domain="googleapis.com",
@@ -137,10 +137,10 @@ def test__get_api_endpoint_mtls_auto_no_cert():
     assert endpoint == "foo.googleapis.com"
 
 
-def test__get_api_endpoint_mtls_universe_mismatch():
+def test_get_api_endpoint_mtls_universe_mismatch():
     # mTLS is only supported in the default universe
     with pytest.raises(MutualTLSChannelError, match="mTLS is not supported"):
-        client_helpers._get_api_endpoint(
+        client_helpers.get_api_endpoint(
             api_override=None,
             client_cert_source=mock.Mock(),
             universe_domain="custom-universe.com",
@@ -151,80 +151,93 @@ def test__get_api_endpoint_mtls_universe_mismatch():
         )
 
 
-@mock.patch("google.api_core.gapic_v1.client_helpers._use_client_cert_effective")
+@mock.patch(
+    "google.api_core.gapic_v1.client_helpers.use_client_cert_effective"
+)
 @mock.patch.dict(os.environ, clear=True)
-def test__read_environment_variables(mock_effective):
+def test_read_environment_variables(mock_effective):
     mock_effective.return_value = True
     os.environ["GOOGLE_API_USE_MTLS_ENDPOINT"] = "always"
     os.environ["GOOGLE_CLOUD_UNIVERSE_DOMAIN"] = "custom.com"
 
-    cert, mtls, domain = client_helpers._read_environment_variables()
+    cert, mtls, domain = client_helpers.read_environment_variables()
     assert cert is True
     assert mtls == "always"
     assert domain == "custom.com"
 
 
 @mock.patch.dict(os.environ, clear=True)
-def test__read_environment_variables_invalid_mtls():
+def test_read_environment_variables_invalid_mtls():
     os.environ["GOOGLE_API_USE_MTLS_ENDPOINT"] = "invalid"
     with pytest.raises(
         MutualTLSChannelError, match="must be `never`, `auto` or `always`"
     ):
-        client_helpers._read_environment_variables()
+        client_helpers.read_environment_variables()
 
 
-@mock.patch("google.auth.transport.mtls.has_default_client_cert_source", create=True)
-@mock.patch("google.auth.transport.mtls.default_client_cert_source", create=True)
-def test__get_client_cert_source(mock_default, mock_has_default):
+@mock.patch(
+    "google.auth.transport.mtls.has_default_client_cert_source", create=True
+)
+@mock.patch(
+    "google.auth.transport.mtls.default_client_cert_source", create=True
+)
+def test_get_client_cert_source(mock_default, mock_has_default):
     mock_default.return_value = b"default_cert"
     mock_has_default.return_value = True
 
     # When use_cert_flag is False, return None
-    assert client_helpers._get_client_cert_source(b"provided", False) is None
+    assert client_helpers.get_client_cert_source(b"provided", False) is None
 
     # When provided_cert_source is given, return provided
-    assert client_helpers._get_client_cert_source(b"provided", True) == b"provided"
+    assert (
+        client_helpers.get_client_cert_source(b"provided", True)
+        == b"provided"
+    )
 
     # When no provided cert but default is available
-    assert client_helpers._get_client_cert_source(None, True) == b"default_cert"
+    assert client_helpers.get_client_cert_source(None, True) == b"default_cert"
 
 
-def test__get_universe_domain():
+def test_get_universe_domain():
     # client_universe_domain takes precedence
     assert (
-        client_helpers._get_universe_domain("client.com", "env.com", "default.com")
+        client_helpers.get_universe_domain(
+            "client.com", "env.com", "default.com"
+        )
         == "client.com"
     )
 
     # env takes precedence over default
     assert (
-        client_helpers._get_universe_domain(None, "env.com", "default.com") == "env.com"
+        client_helpers.get_universe_domain(None, "env.com", "default.com")
+        == "env.com"
     )
 
     # fallback to default
     assert (
-        client_helpers._get_universe_domain(None, None, "default.com") == "default.com"
+        client_helpers.get_universe_domain(None, None, "default.com")
+        == "default.com"
     )
 
 
-def test__get_universe_domain_empty():
+def test_get_universe_domain_empty():
     with pytest.raises(ValueError, match="cannot be an empty string"):
-        client_helpers._get_universe_domain("", None, "default.com")
+        client_helpers.get_universe_domain("", None, "default.com")
 
 
-def test__setup_request_id():
+def test_setup_request_id():
     import uuid
 
     # test dict request
     req = {}
-    client_helpers._setup_request_id(req, "request_id", True)
+    client_helpers.setup_request_id(req, "request_id", True)
     assert "request_id" in req
     uuid_str = req["request_id"]
     uuid.UUID(uuid_str)  # verify it is a valid UUID
 
     # test dict request when already set
     req = {"request_id": "existing"}
-    client_helpers._setup_request_id(req, "request_id", True)
+    client_helpers.setup_request_id(req, "request_id", True)
     assert req["request_id"] == "existing"
 
     class DummyRequest:
@@ -238,12 +251,12 @@ def HasField(self, field_name):
 
     # test object request proto3 optional true
     req_obj = DummyRequest()
-    client_helpers._setup_request_id(req_obj, "request_id", True)
+    client_helpers.setup_request_id(req_obj, "request_id", True)
     assert req_obj.request_id != ""
     uuid.UUID(req_obj.request_id)
 
     # test object request proto3 optional false
     req_obj2 = DummyRequest()
-    client_helpers._setup_request_id(req_obj2, "request_id", False)
+    client_helpers.setup_request_id(req_obj2, "request_id", False)
     assert req_obj2.request_id != ""
     uuid.UUID(req_obj2.request_id)