GET /contractors
174208
def search(*params, &block)
      options = {:query => {}}
      options[:query] = params[0] if params.length > 0      
      response = self.class.get "/contractors/#{keywords.join(', ')}", options
      yield(response) if block_given?
      response
    end
582525
def get_all(options = {})
      custom_params = options[:dc] ? use_named_parameter('dc', options[:dc]) : nil
      ret = send_get_request(@conn, ['/v1/catalog/services'], options, custom_params)
      OpenStruct.new JSON.parse(ret.body)
    end
721306
function needBuild(mode, system, cdef, out, cb) {
    // TODO handle authentication and HTTPS registries
    // also handle other registries than docker-registry-container

    var cmds = commands(os.platform());
    var tag = cmds.generateTag(config, system, cdef);
    var baseUrl = 'http://' + config.registry + '/v1/repositories';
    var url = tag.replace(config.registry,
                          baseUrl) + '/tags';

    request({ url: url, json: true }, function(err, res, body) {
      if (err) { return cb(err); }

      // return the missing definition, or null
      cb(null, Object.keys(body).length === 0 ? cdef : null);
    });
  }
737056
def do_GET(self):
        """"""
        self.do_HEAD()
        template = pkg_resources.resource_string(__name__, "static/splash.html")
        page = template.decode('utf-8').format(self.headers.get("User-Agent"), self.cache)
        self.wfile.write(page.encode('utf-8'))
1027876
def get(self, urls=None, **overrides):
        """"""
        if urls is not None:
            overrides['urls'] = urls
        return self.where(accept='GET', **overrides)
214572
function getReferrerUrl(bidderRequest) {
  let referer = '';
  if (bidderRequest && bidderRequest.refererInfo) {
    referer = encodeURIComponent(bidderRequest.refererInfo.referer);
  }
  return referer;
}
723676
def _get_jobs_url(self):
        """"""
        if self._jobs_url is None:
            self.get_instance_status()
            if self._jobs_url is None:
                raise ValueError("Cannot obtain jobs URL")
        return self._jobs_url
117116
def get(self, ids, **kwargs):
        

        url = build_uri_with_ids('api/v3/interface/%s/', ids)

        return super(ApiInterfaceRequest, self).get(self.prepare_url(url, kwargs))
800635
def fetch_pull_request_url(repo_slug, build_number, token)
      build_json = fetch_build(repo_slug, build_number, token)
      pull_requests = build_json[:pull_requests]
      return nil unless pull_requests.first
      pull_requests.first[:url]
    end
161357
def get_contract_by_hash(self, contract_hash):
        """"""
        contract_address = self.db.reader._get_address_by_hash(contract_hash)
        if contract_address is not None:
            return contract_address

        else:
            raise AddressNotFoundError
581553
def get(self, *jids):
        ''''''
        if jids:
            return [
                Job(self.client, **j) for j in
                json.loads(self.client('multiget', *jids))]
        return []
1062502
def get(self, multihash, **kwargs):
        
        args = (multihash,)
        return self._client.download('/get', args, **kwargs)
441192
def get(pattern, opts={})
      path = build_url(pattern, opts)
      request(:get, path, opts)
    end
378790
def do_get(endpoint, access_token):
    '''
    '''
    headers = {"Authorization": 'Bearer ' + access_token}
    headers['User-Agent'] = get_user_agent()
    return requests.get(endpoint, headers=headers).json()
1103869
function(bidRequests) {
    return bidRequests.map(bidRequest => {
      let giBidRequest = buildGiBidRequest(bidRequest);
      return {
        method: 'GET',
        url: buildUrl(giBidRequest),
        data: giBidRequest,
      };
    });
  }
513018
def get(path: nil, headers: {}, query: {})
      execute(method: :get, path: path, query: query, headers: headers)
    end
81556
function urlBuilder(params) {
  var builtUrl = params.base;

  builtUrl += '?';

  if (params.apiKey) {
    builtUrl += 'key=' + params.apiKey + '&';
  }

  if (params.client) {
    builtUrl += 'client=' + params.client + '&';
  }

  if (params.libraries.length > 0) {
    builtUrl += 'libraries=';

    params.libraries.forEach(function(library, index) {
      builtUrl += library;

      if (index !== params.libraries.length - 1) {
        builtUrl += ',';
      }
    });

    builtUrl += '&';
  }

  if (params.language) {
    builtUrl += 'language=' + params.language + '&';
  }

  if (params.version) {
    builtUrl += 'v=' + params.version + '&';
  }

  builtUrl += 'callback=' + params.callback;

  return builtUrl;
}