Lazy-loading getter GAPIC Firestore API.

        Returns:
            ~.gapic.firestore.v1beta1.firestore_client.FirestoreClient: The
            GAPIC client with the credentials of the current client.
339867
def _firestore_api(self):
        
        if self._firestore_api_internal is None:
            self._firestore_api_internal = firestore_client.FirestoreClient(
                credentials=self._credentials
            )

        return self._firestore_api_internal
325716
def get_client_secret(self):
        
        self._client_secret = predix.config.get_env_value(predix.app.Manifest, 'client_secret')
        return self._client_secret
964252
def _get_gcloud_sdk_credentials():
    """"""
    from google.auth import _cloud_sdk

    # Check if application default credentials exist.
    credentials_filename = (
        _cloud_sdk.get_application_default_credentials_path())

    if not os.path.isfile(credentials_filename):
        return None, None

    credentials, project_id = _load_credentials_from_file(
        credentials_filename)

    if not project_id:
        project_id = _cloud_sdk.get_project_id()

    return credentials, project_id
1050105
def get_token(self):
        
        if not self.authenticated:
            raise ValueError("Must authenticate() as a client first.")

        # If token has expired we'll need to refresh and get a new
        # client credential
        if self.is_expired_token(self.client):
            logging.info("client token expired, will need to refresh token")
            self.authenticate(self.client['id'], self.client['secret'],
                    use_cache=False)

        return self.client['access_token']
1240319
function getClientById(snapshot, clientId, apiId, done) {
  logger.debug('getClientById entry');

  // build request to send to data-store
  var queryfilter = { where: { and: [] } };
  queryfilter.where.and[0] = { 'snapshot-id': snapshot };
  queryfilter.where.and[1] = { 'api-id': apiId };
  queryfilter.where.and[2] = { 'client-id': clientId };

  var queryurlObj = {
    protocol: 'http',
    hostname: host,
    port: process.env.DATASTORE_PORT,
    pathname: '/api/optimizedData',
    query: { filter: JSON.stringify(queryfilter) } };
  var queryurl = url.format(queryurlObj);

  const cached = cache[queryurl];
  if (cached && useCache) {
    done(undefined, cached);
  } else {
    request({ url: queryurl, json: true }, function(error, response, body) {
      if (error) {
        logger.debug('error: ', error);
        return done(error);
      }

      var optimizedData = body;
      if (!optimizedData || optimizedData.length === 0) {
        return done('no matched client');
      }
      cache[queryurl] = optimizedData;
      done(undefined, optimizedData);
    });
  }
}
43021
def get_client(self, request=None):
        """"""

        if not isinstance(request, oauth.Request):
            request = self.get_oauth_request()
        client_key = request.get_parameter('oauth_consumer_key')
        if not client_key:
            raise Exception('Missing "oauth_consumer_key" parameter in ' \
                'OAuth "Authorization" header')

        client = models.Client.get_by_key_name(client_key)
        if not client:
            raise Exception('Client "%s" not found.' % client_key)

        return client
714318
public Page<Bucket> authListBuckets() {
    // [START auth_cloud_implicit]
    // If you don't specify credentials when constructing the client, the
    // client library will look for credentials in the environment.

    Storage storage = StorageOptions.getDefaultInstance().getService();

    Page<Bucket> buckets = storage.list();
    for (Bucket bucket : buckets.iterateAll()) {
      // do something with the info
    }
    // [END auth_cloud_implicit]
    return buckets;
  }
622754
function get_client() {
		if (client_cache) return Promise.resolve(client_cache);
		return make_promise(
			cypher.createClient.bind(cypher, connection_string, connection_opts)
		).then(cache_client);
	}
896925
def Get(self):
    """"""

    args = client_pb2.ApiGetClientArgs(client_id=self.client_id)
    result = self._context.SendRequest("GetClient", args)
    return Client(data=result, context=self._context)
599996
def get_results(self, client):
        
        data = self._request('GET', '/results/{}'.format(client))
        return data.json()
801165
function Client (id, apiKey) {
	if (!(this instanceof Client)) {
		return new Client(id, apiKey);
	}

	this.endpoint = 'https://www.googleapis.com';
	this.apiKey = apiKey;
	this.id = id;
}
1227211
<RequestT, ResponseT> ApiFuture<ResponseT> sendRequest(
      RequestT requestT, UnaryCallable<RequestT, ResponseT> callable) {
    Preconditions.checkState(!closed, "Firestore client has already been closed");
    return callable.futureCall(requestT);
  }
1128640
def get_client_data(self, client):
        
        data = self._request('GET', '/clients/{}'.format(client))
        return data.json()
354205
def get_collection(self, **kwargs):
        
        from pymongo import MongoClient

        if self.host and self.port:
            client = MongoClient(host=config.host, port=config.port)
        else:
            client = MongoClient()
        db = client[self.dbname]

        # Authenticate if needed
        if self.user and self.password:
            db.autenticate(self.user, password=self.password)

        return db[self.collection]
911202
def get_client(client_id):
    
    client = Client.query.get(client_id)
    if client and client.user.active:
        return client
610916
public CloseableHttpClient getHttpClient() {
        CloseableHttpClient result = httpClient;
        if (result == null) {
            synchronized (DocumentLoader.class) {
                result = httpClient;
                if (result == null) {
                    result = httpClient = JsonUtils.getDefaultHttpClient();
                }
            }
        }
        return result;
    }
761923
def fetch(self):
        
        params = values.of({})

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return AuthorizedConnectAppInstance(
            self._version,
            payload,
            account_sid=self._solution['account_sid'],
            connect_app_sid=self._solution['connect_app_sid'],
        )