Perform an HTTP PUT request
548543
def put(path, token, query: {}, payload: {})
      request(:put, path, token, query, payload)
    end
694679
def put(self, uri, data, **kwargs):
        
        return self.request("PUT", uri, data=data, **kwargs)
804993
def http_method(self, data):
        """"""
        data = data.upper()
        if data in ['DELETE', 'GET', 'POST', 'PUT']:
            self._http_method = data

            # set content type for commit methods (best guess)
            if self._headers.get('Content-Type') is None and data in ['POST', 'PUT']:
                self.add_header('Content-Type', 'application/json')
        else:
            raise AttributeError(
                'Request Object Error: {} is not a valid HTTP method.'.format(data)
            )
971443
public JSONObject put(String path, Map<String, Object> params) throws APIError {
        return request(Verb.PUT, path, params);
    }
199157
def put_json(self, uri, data, **kwargs):
        
        encoded_data = json.dumps(data)
        kwargs.setdefault("headers", {}).update({
            "Content-Type": "application/json",  # tell server we are sending json
        })
        return self.put(uri, data=encoded_data, **kwargs)
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
960465
public Object putRequest(String restUrl, Map<String, String> params) throws IOException, WebServiceException {
		return this.postRequest(HttpMethod.PUT, restUrl, params);
	}
219102
private <T> PubsubFuture<T> put(final String operation, final String path, final Object payload,
                                  final ResponseReader<T> responseReader) {
    return request(operation, HttpMethod.PUT, path, payload, responseReader);
  }
481833
def put(path, stream, length)
      path = @uri.merge(path).path
      res = @handler.request_sending_stream(:put, path, stream, length, @headers)
      res.body
    end
410712
def put(self, request, id, format=None):
        
        bot = self.get_bot(id, request.user)
        serializer = BotUpdateSerializer(bot, data=request.data)
        if serializer.is_valid():
            try:
                bot = serializer.save()
            except:
                return Response(status=status.HTTP_400_BAD_REQUEST)
            else:
                return Response(BotSerializer(bot).data)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
1218679
def put(self, urls=None, **overrides):
        """"""
        if urls is not None:
            overrides['urls'] = urls
        return self.where(accept='PUT', **overrides)
591777
def do_PUT(self):
        
        self.do_initial_operations()
        payload = self.coap_uri.get_payload()
        if payload is None:
            logger.error("BAD PUT REQUEST")
            self.send_error(BAD_REQUEST)
            return
        logger.debug(payload)
        coap_response = self.client.put(self.coap_uri.path, payload)
        self.client.stop()
        logger.debug("Server response: %s", coap_response.pretty_print())
        self.set_http_response(coap_response)
763934
def put(self, url, headers=None, body=None, kwargs=None):
        
        return self._request(
            method='put',
            url=url,
            headers=headers,
            body=body,
            kwargs=kwargs
        )
996832
function put($url = "",$options = array()){
		if(is_array($url)){
			$options = $url;
			$url = "";
		}
		$options["request_method"] = "PUT";
		return $this->fetchContent($url,$options);
	}
1226968
def put(self, path, data, **options):
        """"""
        parameter_options = self._parse_parameter_options(options)
        body = {
            # values in the data body takes precendence
            'data': _merge(parameter_options, data),
            'options': self._parse_api_options(options)
        }
        headers = _merge(
            {'content-type': 'application/json'},
            options.pop('headers', {})
        )
        return self.request('put', path, data=body, headers=headers, **options)
889854
def put(self, url, data):
        
        response = self._run_method('PUT', url, data=data)
        log.debug("OUTPUT: %s" % response.content)
        return self._handle_response(url, response)
786863
def on_put(self, request, response, txn_id=None):
        """"""
        response.body = "{}"

        # Check whether repeat txn_id
        if not self._is_new(txn_id):
            response.status = falcon.HTTP_200
            return

        request.context["body"] = request.stream.read()
        try:
            events = json.loads(request.context["body"].decode("utf-8"))["events"]
        except(KeyError, ValueError, UnicodeDecodeError):
            response.status = falcon.HTTP_400
            response.body = "Malformed request body"
            return

        if self.handler(EventStream(events, self.Api)):
            response.status = falcon.HTTP_200
        else:
            response.status = falcon.HTTP_400