code: def __init__(self, api_token=None, proxies=None):
      self._old_leaderboard_client = None
      self._new_leaderboard_client = None
      self._api_token = api_token
      self._proxies = proxies
  
      # This is not a top-level import because of circular dependencies
      from neptune import __version__
  
      self.client_lib_version = __version__
  
      self.credentials = Credentials(api_token)
  
      ssl_verify = True
      if os.getenv("NEPTUNE_ALLOW_SELF_SIGNED_CERTIFICATE"):
          urllib3.disable_warnings()
          ssl_verify = False
  
      self._http_client = RequestsClient(
          ssl_verify=ssl_verify,
          response_adapter_class=NeptuneResponseAdapter,
      )
      # for session re-creation we need to keep an authenticator-free version of http client
      self._http_client_for_token = RequestsClient(
          ssl_verify=ssl_verify,
          response_adapter_class=NeptuneResponseAdapter,
      )
  
      user_agent = "neptune-client/{lib_version} ({system}, python {python_version})".format(
          lib_version=self.client_lib_version,
          system=platform.platform(),
          python_version=platform.python_version(),
      )
      self.http_client.session.headers.update(
          {"User-Agent": user_agent}
      )
      self._http_client_for_token.session.headers.update(
          {"User-Agent": user_agent}
      )
  
      update_session_proxies(self.http_client.session, proxies)
      update_session_proxies(
          self._http_client_for_token.session, proxies
      )
  
      config_api_url = (
          self.credentials.api_url_opt
          or self.credentials.token_origin_address
      )
      # We don't need to be able to resolve Neptune host if we use proxy
      if proxies is None:
          self._verify_host_resolution(
              config_api_url, self.credentials.token_origin_address
          )
  
      # this backend client is used only for initial configuration and session re-creation
      self.backend_client = self._get_swagger_client(
          "{}/api/backend/swagger.json".format(config_api_url),
          self._http_client_for_token,
      )
      self._client_config = self._create_client_config(
          api_token=self.credentials.api_token,
          backend_client=self.backend_client,
      )
  
      self._verify_version()
  
      self.backend_swagger_client = self._get_swagger_client(
          "{}/api/backend/swagger.json".format(
              self._client_config.api_url
          ),
          self.http_client,
      )
  
      self.authenticator = self._create_authenticator(
          api_token=self.credentials.api_token,
          ssl_verify=ssl_verify,
          proxies=proxies,
          backend_client=self.backend_client,
      )
      self.http_client.authenticator = self.authenticator
  
      if sys.version_info >= (3, 7):
          try:
              os.register_at_fork(
                  after_in_child=self._handle_fork_in_child
              )
          except AttributeError:
              pass
  
imports: import logging
  import os
  import platform
  import sys
  import click
  import urllib3
  from bravado.exception import HTTPNotFound
  from bravado.requests_client import RequestsClient
  from packaging import version
  from neptune.common.exceptions import STYLES
  from neptune.common.oauth import NeptuneAuthenticator
  from neptune.common.utils import NoopObject, update_session_proxies
  from neptune.internal.backends.hosted_client import NeptuneResponseAdapter
  from neptune.legacy.api_exceptions import ProjectNotFound, WorkspaceNotFound
  from neptune.legacy.backend import BackendApiClient, LeaderboardApiClient
  from neptune.legacy.exceptions import UnsupportedClientVersion
  from neptune.legacy.internal.api_clients.credentials import Credentials
  from neptune.legacy.internal.api_clients.hosted_api_clients.hosted_alpha_leaderboard_api_client import HostedAlphaLeaderboardApiClient
  from neptune.legacy.internal.api_clients.hosted_api_clients.mixins import HostedNeptuneMixin
  from neptune.legacy.internal.api_clients.hosted_api_clients.utils import legacy_with_api_exceptions_handler
  from neptune.legacy.projects import Project
label_desc: Use image node_id 1 to create a new HostedNeptuneBackendApiClient object from inherited base classes: HostedNeptuneMixin, BackendApiClient with example: obj = HostedNeptuneBackendApiClient(api_token, proxies)