Sends this `Resource` instance to the service with a
        ``POST`` request to the given URL. Takes an optional body
489331
def post(self, url, body=None):
        """"""
        response = self.http_request(url, 'POST', body or self, {'Content-Type': 'application/xml; charset=utf-8'})
        if response.status not in (200, 201, 204):
            self.raise_http_error(response)

        self._url = response.getheader('Location')

        if response.status in (200, 201):
            response_xml = response.read()
            logging.getLogger('recurly.http.response').debug(response_xml)
            self.update_from_element(ElementTree.fromstring(response_xml))
881053
def post(url, params)
      params = convert_hash_keys(params)
      preform(url, :post, params: params) do
        return connection.post(url, params)
      end
    end
912593
def post_resource(url, body):
    
    response = Bridge_DAO().postURL(url, PHEADER, body)
    log_data = "POST %s %s ==status==> %s" % (url, body, response.status)

    if response.status != 200 and response.status != 201:
        # 201 Created
        _raise_exception(log_data, url, response)

    _log_resp(log_data, response.data)
    return response.data
850169
def _post(self, url, params, uploads=None):
        
        self._call(self.POST, url, params, uploads)
751493
def post(url, data={}, options={})
      response = connection.post do |req|
        req.saddle_options = options
        req.url(url)
        req.body = data
      end
      handle_response(response)
    end
1285967
def post(path, data, options = {})
      uri = build_uri(path, options)

      request = Net::HTTP::Post.new(uri.request_uri)
      set_authorisation_header(request)
      request.set_form_data(data)

      response = https_client(uri).request(request)
    end
108047
def post(self, action, data=None, headers=None):
        
        return self.request(make_url(self.endpoint, action), method='POST', data=data,
                            headers=headers)
1072733
function send(url, method, options, resourceName) {
            var deferred = $q.defer();
            var key, val, paramArray = [];

            url = config.apiBase + url;
            options = options || {};

            // separate out data if it exists
            var data = options.data;
            delete options.data;

            // attempt to add id to the url if it exists
            if (url.indexOf('{_id}') >= 0) {
                if (options._id) {
                    url = url.replace('{_id}', options._id);
                    delete options._id;
                }
                else if (data && data._id) {
                    url = url.replace('{_id}', data._id);
                }
            }
            else if (method === 'GET' && options._id) {
                url += '/' + options._id;
                delete options._id;
            }

            var showErr = options.showErr !== false;
            delete options.showErr;

            // add params to the URL
            options.lang = options.lang || config.lang;
            for (key in options) {
                if (options.hasOwnProperty(key) && options[key]) {
                    val = options[key];
                    val = angular.isObject(val) ? JSON.stringify(val) : val;

                    paramArray.push(encodeURIComponent(key) + '=' + encodeURIComponent(val));
                }
            }

            // add params to URL
            if (paramArray.length) {
                url += '?' + paramArray.join('&');
            }

            // set up the api options
            var apiOpts = {
                method:     method,
                url:        url
            };

            // if the jwt exists, add it to the request
            var jwt = storage.get('jwt');
            if (jwt && jwt !== 'null') {  // hack fix; someone setting localStorage to 'null'
                apiOpts.headers = {
                    Authorization: jwt
                };
            }

            // add data to api options if available
            if (data) {
                apiOpts.data = data;
            }

            // emit events for start and end so realtime services can stop syncing for post
            eventBus.emit(resourceName + '.' + method.toLowerCase() + '.start');

            // finally make the http call
            $http(apiOpts)
                .then(function (respData) {
                    respData = respData || {};
                    saveOpts(apiOpts);
                    deferred.resolve(respData.data); //deferred.resolve(respData.data || respData);
                })
                .catch(function (err) {

                    // if (status > 450 && status < 499) {
                    //     eventBus.emit('error.' + status, err);
                    //     return;
                    // }

                    saveOpts(apiOpts);
                    // var isTimeout = !status || status === -1;

                    // if (!err && isTimeout) {
                    //     err = new Error('Cannot access back end');
                    // }
                    if (!err) {
                        err = new Error('error httpCode ' + status + ' headers ' +
                            JSON.stringify(headers) + ' conf ' +
                            JSON.stringify(conf));
                    }

                    if (showErr) {
                        eventBus.emit('error.api', err);
                    }

                    log.error(err, {
                        apiOpts: apiOpts,
                        status: status,
                        headers: headers
                    });

                    deferred.reject(err);
                })
                .finally(function () {
                    eventBus.emit(resourceName + '.' + method.toLowerCase() + '.end');
                });

            return deferred.promise;
        }
545688
def post(path, obj, params = {}, headers = {}, auth = true)
      request(http_method: :post, path: path, body: obj, query: params, headers: headers, auth: auth)
    end
854495
def request(http_method, path, params)
      response = connection.send(http_method, path, params)
      response.body
    end
925683
def post(self, url, data=None, **kwargs):
        """"""
        return requests.post(url, data=data, headers=self.add_headers(**kwargs))
703297
def post(url, params = {}, options = {})
      post_request = Net::HTTP::Post.new(url)
      post_request.body = Gateway.parsed_params( wrap(:post, url, params) )
      post_request.content_type = 'application/x-www-form-urlencoded'
      self.call( post_request, options.merge(:format => params[:format]) )
    end
10996
def put(self, url, data=None, params=None):
        
        return self.request("put", url, data, params)
1018789
def post(self, resource, data=None, json=None):
        
        return self.do(resource, 'POST', data=data, json=json)
1140396
def put(self, url, params=None, headers=None, content=None, form_content=None):
        # type: (str, Optional[Dict[str, str]], Optional[Dict[str, str]], Any, Optional[Dict[str, Any]]) -> ClientRequest
        
        request = self._request('PUT', url, params, headers, content, form_content)
        return request
337846
def http_post(url, data)
    req = HTTPI::Request.new(:url => url, :body => data)
    return HTTPI.post(req).body
  end
433277
def _post_request(self, url, data=None, json=None, **kwargs):
        
        '''  '''
        
    # construct request kwargs
        request_kwargs = {
            'method': 'POST',
            'url': url,
            'data': data,
            'json': json
        }
        for key, value in kwargs.items():
            request_kwargs[key] = value

    # send request and handle response
        return self._request(**request_kwargs)