POST /venues/:id/
        Updates a :format:`venue` and returns it as an object.
498015
def post_venue(self, id, **data):
        
        
        return self.post("/venues/{0}/".format(id), data=data)
1071841
def update_dict_id_field_from_response_field(cls, dict_, dict_id_field,
                                                 response_obj, response_field,
                                                 response_param):
        

        url = response_obj[response_field]

        if url is not None:
            url_parsed = urlparse.urlparse(url)
            parameters = urlparse.parse_qs(url_parsed.query)
            dict_[dict_id_field] = int(
                parameters[response_param][cls._INDEX_FIRST]
            )

            if cls._FIELD_COUNT in parameters and cls._FIELD_COUNT not in dict_:
                dict_[cls._FIELD_COUNT] = int(
                    parameters[client.Pagination.PARAM_COUNT][cls._INDEX_FIRST]
                )
620336
def update_release(id, **kwargs):
    
    data = update_release_raw(id, **kwargs)
    if data:
        return utils.format_json(data)
729319
def update(registration_id, tags_add: nil, tags_remove: nil, clear_tags: false, alis: nil, mobile: nil)
      tags =
        if clear_tags
            ''
        else
          hash = {}
          hash[:add] = [tags_add].flatten unless tags_add.nil?
          hash[:remove] = [tags_remove].flatten unless tags_remove.nil?
          hash.empty? ? nil : hash
        end
      body = {
        tags: tags,
        alias: alis,
        mobile: mobile
      }.select { |_, value| !value.nil? }

      url = base_url + registration_id
      Http::Client.post(@jpush, url, body: body)
    end
490336
def post(self, request, *args, **kwargs):
        
        return self.update_type(request, *args, **kwargs)
1007850
def update_room(self, stream_id, room_definition):
        '''  '''
        req_hook = 'pod/v2/room/' + str(stream_id) + '/update'
        req_args = json.dumps(room_definition)
        status_code, response = self.__rest__.POST_query(req_hook, req_args)
        self.logger.debug('%s: %s' % (status_code, response))
        return status_code, response
1357961
def visitor_update(self, visitor_id, data, **kwargs):
        ""
        api_path = "/api/v2/visitors/{visitor_id}"
        api_path = api_path.format(visitor_id=visitor_id)
        return self.call(api_path, method="PUT", data=data, **kwargs)
726028
def request_booking_details(self, poll_url, **params):
        
        return self.make_request("%s/booking" % poll_url,
                                 method='put',
                                 headers=self._headers(),
                                 callback=lambda resp: resp.headers[
                                     'location'],
                                 **params)
1248517
def update_ticket(self, ticket_id, **kwargs):
        """"""
        url = 'tickets/%d' % ticket_id
        ticket = self._api._put(url, data=json.dumps(kwargs))
        return Ticket(**ticket)
1222072
def POST(self, id):
        
        id = int(id)
        model.del_todo(id)
        raise web.seeother('/')
433591
def post_event_ticket_class(self, id, ticket_class_id, **data):
        
        
        return self.post("/events/{0}/ticket_classes/{0}/".format(id,ticket_class_id), data=data)
686773
def update!(opts={})
      response = Hubspot::Connection.post_json(FORM_PATH, params: { form_guid: @guid }, body: opts)
      self.send(:assign_properties, response)
      self
    end
606687
def media_update(self, id, description=None, focus=None):
        
        id = self.__unpack_id(id)

        if focus != None:
            focus = str(focus[0]) + "," + str(focus[1])
            
        params = self.__generate_params(locals(), ['id'])  
        return self.__api_request('PUT', '/api/v1/media/{0}'.format(str(id)), params)
468298
def update(self, status):
        
        data = values.of({'Status': status, })

        payload = self._version.update(
            'POST',
            self._uri,
            data=data,
        )

        return RoomInstance(self._version, payload, sid=self._solution['sid'], )
249262
def cancel_room(self, booking_id):
        
        resp = self._request("POST", "/1.1/space/cancel/{}".format(booking_id))
        return resp.json()
275769
def update(self, **kwargs):
        ""
        kw = dict(index=self.name, doc_type=self.doc_type, ignore=[404])
        kw.update(**kwargs)
        return self._client.update(**kw)
1281781
def update_format(self, format):
        
        self.format = format
        self.request.update(format=self.format.data)