Get a citrination client
179188
def get_client(site=None):
    """"""
    if 'CITRINATION_API_KEY' not in environ:
        raise ValueError("'CITRINATION_API_KEY' is not set as an environment variable")
    if not site:
        site = environ.get("CITRINATION_SITE", "https://citrination.com")
    return CitrinationClient(environ['CITRINATION_API_KEY'], site)
1365540
def get(self, request, bot_id, id, format=None):
        
        return super(KikRecipientList, self).get(request, bot_id, id, format)
720199
def _get_client():
    '''
    
    '''
    client = salt.cloud.CloudClient(
            os.path.join(os.path.dirname(__opts__['conf_file']), 'cloud')
            )
    return client
645128
def _get_client(self):
        
        kwargs = self._storage_parameters

        # Handles unsecure mode
        if self._unsecure:
            kwargs = kwargs.copy()
            kwargs['ssl_compression'] = False

        return _swift.client.Connection(**kwargs)
327920
def get_client_info(self):
        
        iq = aioxmpp.IQ(
            to=self.client.local_jid.bare().replace(localpart=None),
            type_=aioxmpp.IQType.GET,
            payload=xso.Query()
        )

        reply = (yield from self.client.send(iq))
        return reply
1009046
def client(self):
        """"""
        if isinstance(self._client, six.string_types):
            self._client = Client(self._client, self)

        return self._client
287285
def get_new_client(self, public=True):
        
        return self._get_client(public=public, cached=False)
836400
def api(name, url, token, **kwargs):
    """"""
    return Client(token).api(name, url, **kwargs)
558376
def client_for(self, config_path, quiet=False, bootstrap_server=False,
                   create_client=False):
        """"""
        client = None
        abs_path = os.path.abspath(config_path)
        if abs_path in self.clients:
            client = self.clients[abs_path]
        elif create_client:
            client = self.create_client(config_path)
            if client.setup(quiet=quiet, bootstrap_server=bootstrap_server):
                self.clients[abs_path] = client
        return client
563751
def _get_services():
    '''
    
    '''
    handle_scm = win32service.OpenSCManager(
        None, None, win32service.SC_MANAGER_ENUMERATE_SERVICE)

    try:
        services = win32service.EnumServicesStatusEx(handle_scm)
    except AttributeError:
        services = win32service.EnumServicesStatus(handle_scm)
    finally:
        win32service.CloseServiceHandle(handle_scm)

    return services
662179
def c(self):
        """"""
        if self._client is None:
            self._parse_settings()
            self._client = Rumetr(**self.settings)
        return self._client
1274996
def make_client(api_version, session=None,
                endpoint=None, service_type='monitoring'):
    """"""

    client_cls = utils.get_client_class('monitoring', api_version, VERSION_MAP)
    c = client_cls(
        session=session,
        service_type=service_type,
        endpoint=endpoint,
        app_name='monascaclient',
        app_version=version.version_string,
    )

    return c
1034997
function clients(options) {
  options = options || {};
  options.registry = options.registry || Registry.mirrors.nodejitsu;

  var githulk = options.githulk || new GitHulk();

  //
  // Only create a new Registry instance if we've been supplied with a string.
  //
  var npm = 'string' !== typeof options.registry
    ? options.registry
    : new Registry({
      registry: options.registry,
      githulk: githulk
  });

  return {
    git: githulk,
    npm: npm
  };
}
91743
function getCustomer(client) {
  return client.commerce().customer().customerAccount().getAccounts({
    pageSize: 1
  }).then(pickFirst);
}
989117
function(){
        var copy_fields = ['contactPoints'],
            temp_connection = {},
            connection = this._connection;

        for(var fk in copy_fields){
            temp_connection[copy_fields[fk]] = connection[copy_fields[fk]];
        }
        return new cql.Client(temp_connection);
    }
755552
def GetQualifier(self, *args, **kwargs):
        

        qualname = args[0] if args else kwargs['QualifierName']
        try:
            qual = self.qualifiers[self.default_namespace][qualname]
        except KeyError:
            if self.conn is None:
                raise CIMError(
                    CIM_ERR_NOT_FOUND, qualname, conn_id=self.conn_id)
            qual = self.conn.GetQualifier(*args, **kwargs)
        return qual
561022
def get_client(self, client_id):
        ''''''
        client_response = self.get_request('clients/%s' % client_id)
        return Client(self, client_response['client'])