updated client side parameter to include units. changed to only use float to be more explicit

Author: sfc-gh-sshetkar

src/snowflake/connector/auth/_auth.py

@@ -102,7 +102,7 @@ def base_auth_data(
         login_timeout: int | None = None,
         network_timeout: int | None = None,
         socket_timeout: int | None = None,
-        platform_detection_timeout: int | float | None = None,
+        platform_detection_timeout: float | None = None,
     ):
         return {
             "data": {
@@ -124,7 +124,9 @@ def base_auth_data(
                     "LOGIN_TIMEOUT": login_timeout,
                     "NETWORK_TIMEOUT": network_timeout,
                     "SOCKET_TIMEOUT": socket_timeout,
-                    "PLATFORM": detect_platforms(timeout=platform_detection_timeout),
+                    "PLATFORM": detect_platforms(
+                        timeout_seconds=platform_detection_timeout
+                    ),
                 },
             },
         }
@@ -180,7 +182,7 @@ def authenticate(
             self._rest._connection.login_timeout,
             self._rest._connection._network_timeout,
             self._rest._connection._socket_timeout,
-            self._rest._connection._platform_detection_timeout,
+            self._rest._connection._platform_detection_timeout_seconds,
         )
 
         body = copy.deepcopy(body_template)

src/snowflake/connector/connection.py

@@ -197,9 +197,9 @@ def _get_private_bytes_from_file(
     ),  # network timeout (infinite by default)
     "socket_timeout": (None, (type(None), int)),
     "external_browser_timeout": (120, int),
-    "platform_detection_timeout": (
+    "platform_detection_timeout_seconds": (
         None,
-        (type(None), int, float),
+        (type(None), float),
     ),  # Platform detection timeout for CSP metadata endpoints
     "backoff_policy": (DEFAULT_BACKOFF_POLICY, Callable),
     "passcode_in_password": (False, bool),  # Snowflake MFA
@@ -698,12 +698,12 @@ def client_session_keep_alive_heartbeat_frequency(self, value) -> None:
         self._validate_client_session_keep_alive_heartbeat_frequency()
 
     @property
-    def platform_detection_timeout(self) -> int | float | None:
-        return self._platform_detection_timeout
+    def platform_detection_timeout_seconds(self) -> float | None:
+        return self._platform_detection_timeout_seconds
 
-    @platform_detection_timeout.setter
-    def platform_detection_timeout(self, value) -> None:
-        self._platform_detection_timeout = value
+    @platform_detection_timeout_seconds.setter
+    def platform_detection_timeout_seconds(self, value) -> None:
+        self._platform_detection_timeout_seconds = value
 
     @property
     def client_prefetch_threads(self) -> int:

src/snowflake/connector/platform_detection.py

@@ -21,7 +21,7 @@ class _DetectionState(Enum):
     TIMEOUT = "timeout"
 
 
-def is_ec2_instance(timeout):
+def is_ec2_instance(timeout_seconds: float):
     """
     Check if the current environment is running on an AWS EC2 instance.
 
@@ -31,13 +31,13 @@ def is_ec2_instance(timeout):
     It will ignore the token if on IMDSv1 and use the token if on IMDSv2.
 
     Args:
-        timeout: Timeout value for the metadata service request.
+        timeout_seconds: Timeout value for the metadata service request.
 
     Returns:
         _DetectionState: DETECTED if running on EC2, NOT_DETECTED otherwise.
     """
     try:
-        fetcher = IMDSFetcher(timeout=timeout, num_attempts=1)
+        fetcher = IMDSFetcher(timeout=timeout_seconds, num_attempts=1)
         document = fetcher._get_request(
             "/latest/dynamic/instance-identity/document",
             None,
@@ -86,23 +86,23 @@ def is_valid_arn_for_wif(arn: str) -> bool:
     return any(re.match(p, arn) for p in patterns)
 
 
-def has_aws_identity(timeout):
+def has_aws_identity(timeout_seconds: float):
     """
     Check if the current environment has a valid AWS identity for authentication.
 
     If we retrieve an ARN from the caller identity and it is a valid WIF ARN,
     then we assume we have a valid AWS identity for authentication.
 
     Args:
-        timeout: Timeout value for AWS API calls.
+        timeout_seconds: Timeout value for AWS API calls.
 
     Returns:
         _DetectionState: DETECTED if valid AWS identity exists, NOT_DETECTED otherwise.
     """
     try:
         config = Config(
-            connect_timeout=timeout,
-            read_timeout=timeout,
+            connect_timeout=timeout_seconds,
+            read_timeout=timeout_seconds,
             retries={"total_max_attempts": 1},
         )
         caller_identity = boto3.client("sts", config=config).get_caller_identity()
@@ -118,15 +118,15 @@ def has_aws_identity(timeout):
         return _DetectionState.NOT_DETECTED
 
 
-def is_azure_vm(timeout):
+def is_azure_vm(timeout_seconds: float):
     """
     Check if the current environment is running on an Azure Virtual Machine.
 
     If we query the Azure Instance Metadata Service and receive an HTTP 200 response,
     then we assume we are running on an Azure VM.
 
     Args:
-        timeout: Timeout value for the metadata service request.
+        timeout_seconds: Timeout value for the metadata service request.
 
     Returns:
         _DetectionState: DETECTED if on Azure VM, TIMEOUT if request times out,
@@ -136,7 +136,7 @@ def is_azure_vm(timeout):
         token_resp = requests.get(
             "http://169.254.169.254/metadata/instance?api-version=2021-02-01",
             headers={"Metadata": "true"},
-            timeout=timeout,
+            timeout=timeout_seconds,
         )
         return (
             _DetectionState.DETECTED
@@ -174,7 +174,7 @@ def is_azure_function():
 
 
 def is_managed_identity_available_on_azure_vm(
-    timeout, resource=DEFAULT_ENTRA_SNOWFLAKE_RESOURCE
+    timeout_seconds, resource=DEFAULT_ENTRA_SNOWFLAKE_RESOURCE
 ):
     """
     Check if Azure Managed Identity is available and accessible on an Azure VM.
@@ -184,7 +184,7 @@ def is_managed_identity_available_on_azure_vm(
     then we assume managed identity is available.
 
     Args:
-        timeout: Timeout value for the metadata service request.
+        timeout_seconds: Timeout value for the metadata service request.
         resource: The Azure resource URI to request a token for.
 
     Returns:
@@ -194,7 +194,7 @@ def is_managed_identity_available_on_azure_vm(
     endpoint = f"http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource={resource}"
     headers = {"Metadata": "true"}
     try:
-        response = requests.get(endpoint, headers=headers, timeout=timeout)
+        response = requests.get(endpoint, headers=headers, timeout=timeout_seconds)
         return (
             _DetectionState.DETECTED
             if response.status_code == 200
@@ -206,7 +206,7 @@ def is_managed_identity_available_on_azure_vm(
         return _DetectionState.NOT_DETECTED
 
 
-def has_azure_managed_identity(on_azure_vm, on_azure_function, timeout):
+def has_azure_managed_identity(on_azure_vm, on_azure_function, timeout_seconds: float):
     """
     Determine if Azure Managed Identity is available in the current environment.
 
@@ -219,7 +219,7 @@ def has_azure_managed_identity(on_azure_vm, on_azure_function, timeout):
     Args:
         on_azure_vm: Detection state for Azure VM.
         on_azure_function: Detection state for Azure Function.
-        timeout: Timeout value for managed identity checks.
+        timeout_seconds: Timeout value for managed identity checks.
 
     Returns:
         _DetectionState: DETECTED if managed identity is available, TIMEOUT if
@@ -232,7 +232,7 @@ def has_azure_managed_identity(on_azure_vm, on_azure_function, timeout):
             else _DetectionState.NOT_DETECTED
         )
     if on_azure_vm == _DetectionState.DETECTED:
-        return is_managed_identity_available_on_azure_vm(timeout)
+        return is_managed_identity_available_on_azure_vm(timeout_seconds)
     if (
         on_azure_vm == _DetectionState.TIMEOUT
         or on_azure_function == _DetectionState.TIMEOUT
@@ -241,22 +241,24 @@ def has_azure_managed_identity(on_azure_vm, on_azure_function, timeout):
     return _DetectionState.NOT_DETECTED
 
 
-def is_gce_vm(timeout):
+def is_gce_vm(timeout_seconds: float):
     """
     Check if the current environment is running on Google Compute Engine (GCE).
 
     If we query the Google metadata server and receive a response with the
     "Metadata-Flavor: Google" header, then we assume we are running on GCE.
 
     Args:
-        timeout: Timeout value for the metadata service request.
+        timeout_seconds: Timeout value for the metadata service request.
 
     Returns:
         _DetectionState: DETECTED if on GCE, TIMEOUT if request times out,
                         NOT_DETECTED otherwise.
     """
     try:
-        response = requests.get("http://metadata.google.internal", timeout=timeout)
+        response = requests.get(
+            "http://metadata.google.internal", timeout=timeout_seconds
+        )
         return (
             _DetectionState.DETECTED
             if response.headers.get("Metadata-Flavor") == "Google"
@@ -306,15 +308,15 @@ def is_gce_cloud_run_job():
     )
 
 
-def has_gcp_identity(timeout):
+def has_gcp_identity(timeout_seconds: float):
     """
     Check if the current environment has a valid Google Cloud Platform identity.
 
     If we query the GCP metadata service for the default service account email
     and receive a non-empty response, then we assume we have a valid GCP identity.
 
     Args:
-        timeout: Timeout value for the metadata service request.
+        timeout_seconds: Timeout value for the metadata service request.
 
     Returns:
         _DetectionState: DETECTED if valid GCP identity exists, TIMEOUT if request
@@ -324,7 +326,7 @@ def has_gcp_identity(timeout):
         response = requests.get(
             "http://metadata/computeMetadata/v1/instance/service-accounts/default/email",
             headers={"Metadata-Flavor": "Google"},
-            timeout=timeout,
+            timeout=timeout_seconds,
         )
         response.raise_for_status()
         return (
@@ -353,39 +355,39 @@ def is_github_action():
     )
 
 
-def detect_platforms(timeout: int | float | None) -> list[str]:
+def detect_platforms(timeout_seconds: float | None) -> list[str]:
     """
     Detect all potential platforms that the current environment may be running on.
 
     Args:
-        timeout: Timeout value for platform detection requests. Defaults to 0.2 seconds
+        timeout_seconds: Timeout value for platform detection requests. Defaults to 0.2 seconds
                 if None is provided.
 
     Returns:
         list[str]: List of detected platform names. Platforms that timed out will have
                   "_timeout" suffix appended to their name.
     """
-    if timeout is None:
-        timeout = 0.2
+    if timeout_seconds is None:
+        timeout_seconds = 0.2
 
     with ThreadPoolExecutor(max_workers=10) as executor:
         futures = {
-            "is_ec2_instance": executor.submit(is_ec2_instance, timeout),
+            "is_ec2_instance": executor.submit(is_ec2_instance, timeout_seconds),
             "is_aws_lambda": executor.submit(is_aws_lambda),
-            "has_aws_identity": executor.submit(has_aws_identity, timeout),
-            "is_azure_vm": executor.submit(is_azure_vm, timeout),
+            "has_aws_identity": executor.submit(has_aws_identity, timeout_seconds),
+            "is_azure_vm": executor.submit(is_azure_vm, timeout_seconds),
             "is_azure_function": executor.submit(is_azure_function),
-            "is_gce_vm": executor.submit(is_gce_vm, timeout),
+            "is_gce_vm": executor.submit(is_gce_vm, timeout_seconds),
             "is_gce_cloud_run_service": executor.submit(is_gce_cloud_run_service),
             "is_gce_cloud_run_job": executor.submit(is_gce_cloud_run_job),
-            "has_gcp_identity": executor.submit(has_gcp_identity, timeout),
+            "has_gcp_identity": executor.submit(has_gcp_identity, timeout_seconds),
             "is_github_action": executor.submit(is_github_action),
         }
 
         platforms = {key: future.result() for key, future in futures.items()}
 
     platforms["azure_managed_identity"] = has_azure_managed_identity(
-        platforms["is_azure_vm"], platforms["is_azure_function"], timeout
+        platforms["is_azure_vm"], platforms["is_azure_function"], timeout_seconds
     )
 
     detected_platforms = []