class_docstr: A client to interact with Snowflake using SQL API and submit multiple SQL statements in a single request.
  
  In combination with aiohttp, make post request to submit SQL statements for execution,
  poll to check the status of the execution of a statement. Fetch query results asynchronously.
  
  This hook requires the snowflake_conn_id connection. This hooks mainly uses account, schema, database,
   warehouse, private_key_file or private_key_content field must be setup in the connection. Other inputs
    can be defined in the connection or hook instantiation.
  
  :param snowflake_conn_id: Reference to
      :ref:`Snowflake connection id<howto/connection:snowflake>`
  :param account: snowflake account name
  :param authenticator: authenticator for Snowflake.
      'snowflake' (default) to use the internal Snowflake authenticator
      'externalbrowser' to authenticate using your web browser and
      Okta, ADFS or any other SAML 2.0-compliant identify provider
      (IdP) that has been defined for your account
      'https://<your_okta_account_name>.okta.com' to authenticate
      through native Okta.
  :param warehouse: name of snowflake warehouse
  :param database: name of snowflake database
  :param region: name of snowflake region
  :param role: name of snowflake role
  :param schema: name of snowflake schema
  :param session_parameters: You can set session-level parameters at
      the time you connect to Snowflake
  :param token_life_time: lifetime of the JWT Token in timedelta
  :param token_renewal_delta: Renewal time of the JWT Token in timedelta
  :param deferrable: Run operator in the deferrable mode.
docstr: Gets the private key from snowflake connection.
docstr_tok: ["Gets","the","private","key","from","snowflake","connection","."]
code: def get_private_key(self) -> None:
      """Gets the private key from snowflake connection."""
      conn = self.get_connection(self.snowflake_conn_id)
  
      # If private_key_file is specified in the extra json, load the contents of the file as a private key.
      # If private_key_content is specified in the extra json, use it as a private key.
      # As a next step, specify this private key in the connection configuration.
      # The connection password then becomes the passphrase for the private key.
      # If your private key is not encrypted (not recommended), then leave the password empty.
  
      private_key_file = conn.extra_dejson.get(
          "extra__snowflake__private_key_file"
      ) or conn.extra_dejson.get("private_key_file")
      private_key_content = conn.extra_dejson.get(
          "extra__snowflake__private_key_content"
      ) or conn.extra_dejson.get("private_key_content")
  
      private_key_pem = None
      if private_key_content and private_key_file:
          raise AirflowException(
              "The private_key_file and private_key_content extra fields are mutually exclusive. "
              "Please remove one."
          )
      elif private_key_file:
          private_key_pem = Path(private_key_file).read_bytes()
      elif private_key_content:
          private_key_pem = private_key_content.encode()
  
      if private_key_pem:
          passphrase = None
          if conn.password:
              passphrase = conn.password.strip().encode()
  
          self.private_key = serialization.load_pem_private_key(
              private_key_pem,
              password=passphrase,
              backend=default_backend(),
          )
  
imports: from __future__ import annotations
  import uuid
  from datetime import timedelta
  from pathlib import Path
  from typing import Any
  import aiohttp
  import requests
  from cryptography.hazmat.backends import default_backend
  from cryptography.hazmat.primitives import serialization
  from airflow.exceptions import AirflowException
  from airflow.providers.snowflake.hooks.snowflake import SnowflakeHook
  from airflow.providers.snowflake.utils.sql_api_generate_jwt import JWTGenerator
label_desc: Use image node_id 2 for calling the SnowflakeSqlApiHook obj's underlying member method code with example usage: obj.get_private_key() without return types