A generic method to make POST requests to the OpenDNS Investigate API
        on the given URI.
322803
def post(self, uri, params={}, data={}):
        '''
        '''
        return self._session.post(
            urljoin(Investigate.BASE_URL, uri),
            params=params, data=data, headers=self._auth_header,
            proxies=self.proxies
        )
515404
public RequestResponse doPost(String url, Map<String, Object> headers,
            Map<String, Object> urlParams, Object requestData) {
        RequestResponse rr = initRequestResponse("POST", url, headers, urlParams, requestData);
        Request.Builder requestBuilder = buildRequest(url, headers, urlParams)
                .post(buildRequestBody(rr));
        return doCall(client, requestBuilder.build(), rr);
    }
431302
private <TResponse> TResponse callServiceOwnerPostApi(
            String path, Map<String, String> queryParams,
            Object requestBody, Class<TResponse> responseClass) throws AuthleteApiException
    {
        return callPostApi(mServiceOwnerCredentials, path, queryParams, requestBody, responseClass);
    }
295187
private HttpUriRequest makeRequest(URI uri, final String requestBody)
    {
        HttpPost post = new HttpPost(uri);
        post.setEntity(new StringEntity(requestBody, m_contentType));
        return post;
    }
1324953
def do_request(url, type, &_block)
      uri = URI.parse("#{api_url}/#{url}")
      http = Net::HTTP.new(uri.host, uri.port)
      http.use_ssl = true

      request = type.new(uri.request_uri, headers)

      yield request if block_given?

      response = http.request(request)

      parse!(response)
    end
37356
def post(uri, body, opts = {}, &block)
      initialize_socket(uri, opts)
      HttpStream::post(uri, body, opts, &block)
    rescue IOError => e
      raise e unless @intentional_termination
    end
323199
def _make_request(self, path, method='GET', params_=None):
        """"""
        uri = self.api_root + path
        if params_:
            params_['text_format'] = self.response_format
        else:
            params_ = {'text_format': self.response_format}

        # Make the request
        response = None
        try:
            response = self._session.request(method, uri,
                                            timeout=self.timeout,
                                            params=params_)
        except Timeout as e:
            print("Timeout raised and caught:\n{e}".format(e=e))

        # Enforce rate limiting
        time.sleep(max(self._SLEEP_MIN, self.sleep_time))
        return response.json()['response'] if response else None
300232
def post(self, url):
        
        return requests.post(url, data=self.data, headers=self.config.HEADERS)
7976
def post(self, url, postParameters=None, urlParameters=None):
        
        if self.authorized_client:
            if urlParameters:
                getString = self.getParameters(urlParameters)
                req = urllib2.Request(url + "?" + getString)
            else:
                req = urllib2.Request(url)
            postString = self.postParameters(postParameters)
            resp,content = self.authorized_client.request(req, method="POST", body=postString)
            return toUnicode(content)
        else:
            raise IOError("No authorized client available.")
451112
public String performPostRequest(String requestString, String data) throws IOException {
    HttpPost request = new HttpPost(getBaseUrl() + requestString);
    String json = null;

    CloseableHttpClient httpClient = HttpClients.createDefault();
    if (proxies.size() > 0) {
      // We only check the first proxy for now
      Proxy myProxy = proxies.get(0);
      HttpHost proxy = myProxy.getHttpHost();
      RequestConfig config = RequestConfig.custom()
          .setProxy(proxy)
          .setSocketTimeout(myProxy.getProxySocketTimeout())
          .setConnectTimeout(myProxy.getProxyConnectTimeout())
          .setConnectionRequestTimeout(myProxy.getProxyConnectionRequestTimeout())
          .setProxyPreferredAuthSchemes(Arrays.asList(AuthSchemes.BASIC))
          .build();
      request.setConfig(config);
    }
    try {
      logger.debug("------------------------------------------------");
      logger.debug("OSS Index POST: " + getBaseUrl() + requestString);
      logger.debug(data);
      logger.debug("------------------------------------------------");

      request.setEntity(new StringEntity(data));
      CloseableHttpResponse response = httpClient.execute(request);
      int code = response.getStatusLine().getStatusCode();
      if(code < 200 || code > 299) {
        throw new ConnectException(response.getStatusLine().getReasonPhrase() + " (" + code + ")");
      }
      json = EntityUtils.toString(response.getEntity(), "UTF-8");
    } catch(ParseException e) {
      throw new IOException(e);
    } finally {
      httpClient.close();
    }
    return json;
  }
1158124
def post(self, url, data):
        '''  '''
        data.update({'key': self.APIKEY})
        req = r.post(url,
                     data    = json.dumps(data),
                     headers = self.headers,
                     auth    = self.auth)
        return self.process_request(req)
1117546
private base_response post_request(nitro_service service, options option)  throws Exception
	{
		String sessionid = service.get_sessionid();
		String request = resource_to_string(service, sessionid, option);
		return post_data(service,request);
	}
821216
def post_request(url,args)
      uri = URI.parse(url)
      req = Net::HTTP::Post.new(uri.path)
      req.set_form_data(args)
      request(uri,req)
    end
67391
def open_url_seekable(path_url, mode='rt'):
    """"""

    logging.debug("Making request to '%s'", path_url)
    response = urllib.request.urlopen(path_url)
    logging.debug("Got response %s", response.info())

    try:
        response.seek(0)
    except (IOError, AttributeError):
        # Copy into buffer to allow seeking.
        response = io.BytesIO(response.read())
    if "b" in mode:
        return response
    else:
        return io.TextIOWrapper(response)
744374
def set_up_post_request(uri, data, headers, binary_key = nil)
      if !binary_key.nil?
        binary_data = data[binary_key]

        if binary_data.is_a?(StringIO)
          data[binary_key] = UploadIO.new(
            binary_data, "text/plain", "local.path"
          )
        else
          data[binary_key] = UploadIO.new(
            File.open(binary_data), "text/plain"
          )
        end

        req = Net::HTTP::Post::Multipart.new(uri.path, data)
      else
        req = Net::HTTP::Post.new(uri.path, headers)
        req.set_form_data(data)
      end
      req
    end
947638
def _api_post(self, url, **kwargs):
        
        kwargs['url'] = self.url + url
        kwargs['auth'] = self.auth

        headers = deepcopy(self.headers)
        headers.update(kwargs.get('headers', {}))
        kwargs['headers'] = headers
        self._post(**kwargs)
332287
def requests_post(url, data=None, json=None, **kwargs):
    """"""
    return requests_request('post', url, data=data, json=json, **kwargs)