Create a new client for the HNV REST API.
506387
def _get_client():
        """"""
        return utils.get_client(url=CONFIG.HNV.url,
                                username=CONFIG.HNV.username,
                                password=CONFIG.HNV.password,
                                allow_insecure=CONFIG.HNV.https_allow_insecure,
                                ca_bundle=CONFIG.HNV.https_ca_bundle)
65796
public static CuratorFramework newClient(String connectString, int sessionTimeoutMs, int connectionTimeoutMs, RetryPolicy retryPolicy)
    {
        return builder().
            connectString(connectString).
            sessionTimeoutMs(sessionTimeoutMs).
            connectionTimeoutMs(connectionTimeoutMs).
            retryPolicy(retryPolicy).
            build();
    }
182157
def instantiate_client(_unused_client, _unused_to_delete):
    """"""

    # [START client_create_default]
    from google.cloud import logging

    client = logging.Client()
    # [END client_create_default]

    credentials = object()
    # [START client_create_explicit]
    from google.cloud import logging

    client = logging.Client(project="my-project", credentials=credentials)
880308
function createClient() {
  return Asana.Client.create({
    clientId: clientId,
    clientSecret: clientSecret,
    redirectUri: 'http://localhost:' + port + '/oauth_callback'
  });
}
904543
def _create_client(self, clt_class, url, public=True, special=False):
        
        if self.service == "compute" and not special:
            # Novaclient requires different parameters.
            client = pyrax.connect_to_cloudservers(region=self.region,
                    context=self.identity, verify_ssl=self.verify_ssl)
            client.identity = self.identity
        else:
            client = clt_class(self.identity, region_name=self.region,
                    management_url=url, verify_ssl=self.verify_ssl)
        return client
472030
def create(self, name, **kwargs):
        """"""
        return self._write_op(self._create_nosync, name, **kwargs)
527129
def create_service(self, *args, **kwargs):
        
        return self._client.create_service(*args, scope=self.id, **kwargs)
24975
def create_api_deployment(self):
        """"""
        try:
            self.client.create_deployment(restApiId=self.api_id, stageName=self.env)
            self.log.info('Created a deployment resource.')
        except botocore.exceptions.ClientError as error:
            error_code = error.response['Error']['Code']
            if error_code == 'TooManyRequestsException':
                self.log.debug('Retrying. We have hit api limit.')
            else:
                self.log.debug('Retrying. We received %s.', error_code)
522007
public Client<? extends Options, ? extends OptionsBuilder, ? extends RequestBuilder> newClient() {
        if (clientClassName == null) {
            return new DefaultClient();
        } else {
            try {
                return (Client) Thread.currentThread().getContextClassLoader().loadClass(clientClassName).newInstance();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }
544319
def create(self, **kwargs):
        """"""
        body = self.client.create(url=self.base_url,
                                  json=kwargs)
        return body
427952
def create(server, name, project, apikey, output, threshold, verbose):
    
    if verbose:
        log("Entity Matching Server: {}".format(server))

    if threshold is None:
        raise ValueError("Please provide a threshold")

    # Create a new run
    try:
        response = run_create(server, project, apikey, threshold, name)
    except ServiceError as e:
        log("Unexpected response with status {}".format(e.status_code))
        log(e.text)
    else:
        json.dump(response, output)
611515
def create(self, **kwargs):
        """"""
        resp = self.client.create(url=self.base_url,
                                  json=kwargs)
        return resp
892042
def create_api_v4_as(self):
        """"""
        return ApiV4As(
            self.networkapi_url,
            self.user,
            self.password,
            self.user_ldap)
373331
def create(self, networkipv6s):
        

        data = {'networks': networkipv6s}
        return super(ApiNetworkIPv6, self).post('api/v3/networkv6/', data)
367365
function createClient(redisClientOptions) {
  const client = redis.createClient(redisClientOptions);
  if (!client._options) {
    client._options = redisClientOptions;
  }
  return client;
}
517964
static Channel createNewInstance(String name, HFClient clientContext) throws InvalidArgumentException {
        return new Channel(name, clientContext);
    }
1231808
async def new_client_from_config(config_file=None, context=None, persist_config=True):
    """"""
    client_config = type.__call__(Configuration)

    await load_kube_config(config_file=config_file, context=context,
                           client_configuration=client_config,
                           persist_config=persist_config)

    return ApiClient(configuration=client_config)