class_docstr: Retrieves Authenticated client from Hashicorp Vault.
  
  This is purely internal class promoting authentication code reuse between the Hook and the
  SecretBackend, it should not be used directly in Airflow DAGs. Use VaultBackend for backend
  integration and Hook in case you want to communicate with VaultHook using standard Airflow
  Connection definition.
  
  :param url: Base URL for the Vault instance being addressed.
  :param auth_type: Authentication Type for Vault. Default is ``token``. Available values are in
      ('approle', 'aws_iam', 'azure', 'github', 'gcp', 'kubernetes', 'ldap', 'radius', 'token', 'userpass')
  :param auth_mount_point: It can be used to define mount_point for authentication chosen
        Default depends on the authentication method used.
  :param mount_point: The "path" the secret engine was mounted on. Default is "secret". Note that
       this mount_point is not used for authentication if authentication is done via a
       different engine. For authentication mount_points see, auth_mount_point.
  :param kv_engine_version: Selects the version of the engine to run (``1`` or ``2``, default: ``2``).
  :param token: Authentication token to include in requests sent to Vault
      (for ``token`` and ``github`` auth_type).
  :param token_path: path to file containing authentication token to include in requests sent to Vault
      (for ``token`` and ``github`` auth_type).
  :param username: Username for Authentication (for ``ldap`` and ``userpass`` auth_types).
  :param password: Password for Authentication (for ``ldap`` and ``userpass`` auth_types).
  :param key_id: Key ID for Authentication (for ``aws_iam`` and ''azure`` auth_type).
  :param secret_id: Secret ID for Authentication (for ``approle``, ``aws_iam`` and ``azure`` auth_types).
  :param role_id: Role ID for Authentication (for ``approle``, ``aws_iam`` auth_types).
  :param kubernetes_role: Role for Authentication (for ``kubernetes`` auth_type).
  :param kubernetes_jwt_path: Path for kubernetes jwt token (for ``kubernetes`` auth_type, default:
      ``/var/run/secrets/kubernetes.io/serviceaccount/token``).
  :param gcp_key_path: Path to Google Cloud Service Account key file (JSON)  (for ``gcp`` auth_type).
         Mutually exclusive with gcp_keyfile_dict
  :param gcp_keyfile_dict: Dictionary of keyfile parameters. (for ``gcp`` auth_type).
         Mutually exclusive with gcp_key_path
  :param gcp_scopes: Comma-separated string containing OAuth2 scopes (for ``gcp`` auth_type).
  :param azure_tenant_id: The tenant id for the Azure Active Directory (for ``azure`` auth_type).
  :param azure_resource: The configured URL for the application registered in Azure Active Directory
         (for ``azure`` auth_type).
  :param radius_host: Host for radius (for ``radius`` auth_type).
  :param radius_secret: Secret for radius (for ``radius`` auth_type).
  :param radius_port: Port for radius (for ``radius`` auth_type).
code: def __init__(
      self,
      url: str | None = None,
      auth_type: str = "token",
      auth_mount_point: str | None = None,
      mount_point: str | None = "secret",
      kv_engine_version: int | None = None,
      token: str | None = None,
      token_path: str | None = None,
      username: str | None = None,
      password: str | None = None,
      key_id: str | None = None,
      secret_id: str | None = None,
      role_id: str | None = None,
      kubernetes_role: str | None = None,
      kubernetes_jwt_path: str
      | None = "/var/run/secrets/kubernetes.io/serviceaccount/token",
      gcp_key_path: str | None = None,
      gcp_keyfile_dict: dict | None = None,
      gcp_scopes: str | None = None,
      azure_tenant_id: str | None = None,
      azure_resource: str | None = None,
      radius_host: str | None = None,
      radius_secret: str | None = None,
      radius_port: int | None = None,
      **kwargs,
  ):
      super().__init__()
      if (
          kv_engine_version
          and kv_engine_version not in VALID_KV_VERSIONS
      ):
          raise VaultError(
              f"The version is not supported: {kv_engine_version}. "
              f"It should be one of {VALID_KV_VERSIONS}"
          )
      if auth_type not in VALID_AUTH_TYPES:
          raise VaultError(
              f"The auth_type is not supported: {auth_type}. It should be one of {VALID_AUTH_TYPES}"
          )
      if auth_type == "token" and not token and not token_path:
          raise VaultError(
              "The 'token' authentication type requires 'token' or 'token_path'"
          )
      if auth_type == "github" and not token and not token_path:
          raise VaultError(
              "The 'github' authentication type requires 'token' or 'token_path'"
          )
      if auth_type == "approle" and not role_id:
          raise VaultError(
              "The 'approle' authentication type requires 'role_id'"
          )
      if auth_type == "kubernetes":
          if not kubernetes_role:
              raise VaultError(
                  "The 'kubernetes' authentication type requires 'kubernetes_role'"
              )
          if not kubernetes_jwt_path:
              raise VaultError(
                  "The 'kubernetes' authentication type requires 'kubernetes_jwt_path'"
              )
      if auth_type == "azure":
          if not azure_resource:
              raise VaultError(
                  "The 'azure' authentication type requires 'azure_resource'"
              )
          if not azure_tenant_id:
              raise VaultError(
                  "The 'azure' authentication type requires 'azure_tenant_id'"
              )
      if auth_type == "radius":
          if not radius_host:
              raise VaultError(
                  "The 'radius' authentication type requires 'radius_host'"
              )
          if not radius_secret:
              raise VaultError(
                  "The 'radius' authentication type requires 'radius_secret'"
              )
  
      self.kv_engine_version = kv_engine_version or 2
      self.url = url
      self.auth_type = auth_type
      self.kwargs = kwargs
      self.token = token
      self.token_path = token_path
      self.auth_mount_point = auth_mount_point
      self.mount_point = mount_point
      self.username = username
      self.password = password
      self.key_id = key_id
      self.secret_id = secret_id
      self.role_id = role_id
      self.kubernetes_role = kubernetes_role
      self.kubernetes_jwt_path = kubernetes_jwt_path
      self.gcp_key_path = gcp_key_path
      self.gcp_keyfile_dict = gcp_keyfile_dict
      self.gcp_scopes = gcp_scopes
      self.azure_tenant_id = azure_tenant_id
      self.azure_resource = azure_resource
      self.radius_host = radius_host
      self.radius_secret = radius_secret
      self.radius_port = radius_port
  
imports: from __future__ import annotations
  from functools import cached_property
  import hvac
  from hvac.api.auth_methods import Kubernetes
  from hvac.exceptions import InvalidPath, VaultError
  from requests import Response, Session
  from requests.adapters import HTTPAdapter
  from urllib3.util import Retry
  from airflow.utils.log.logging_mixin import LoggingMixin
label_desc: Use image node_id 1 to create a new _VaultClient object from inherited base classes: LoggingMixin with example: obj = _VaultClient(url, auth_type, auth_mount_point, mount_point, kv_engine_version, token, token_path, username, password, key_id, secret_id, role_id, kubernetes_role, kubernetes_jwt_path, gcp_key_path, gcp_keyfile_dict, gcp_scopes, azure_tenant_id, azure_resource, radius_host, radius_secret, radius_port)