Updates a reminder item

        :param reminder_item_id: the reminder item id
        :param reminder_item_dict: dict
        :return: dict
968700
def update_reminder_item(self, reminder_item_id, reminder_item_dict):
        
        return self._create_put_request(
            resource=REMINDER_ITEMS,
            billomat_id=reminder_item_id,
            send_data=reminder_item_dict
        )
866597
def _bin_update_items(self, items, replace_at_most_one,
                          replacements, leftovers):
        
        for key, value in items:
            # If there are existing items with key <key> that have yet to be
            # marked for replacement, mark that item's value to be replaced by
            # <value> by appending it to <replacements>.
            if key in self and key not in replacements:
                replacements[key] = [value]
            elif (key in self and not replace_at_most_one and
                  len(replacements[key]) < len(self.values(key))):
                replacements[key].append(value)
            else:
                if replace_at_most_one:
                    replacements[key] = [value]
                else:
                    leftovers.append((key, value))
672965
def update(self, doc: dict, doc_id: str):
        
        body = {
            'doc': doc
        }
        self.instance.update(self.index, self.doc_type, doc_id, body=body)
157652
def get_all_items_of_reminder(self, reminder_id):
        
        return self._iterate_through_pages(
            get_function=self.get_items_of_reminder_per_page,
            resource=REMINDER_ITEMS,
            **{'reminder_id': reminder_id}
        )
1047634
def create_item_returning_id(self, api):
        
        resp = api.create_item(self)
        item = resp.json()
        return item['id']
78651
def append(self, item):
        
        self.real_list.append(item)
        self.observer(UpdateType.CREATED, item, len(self.real_list) - 1)
45226
def remind_me_at(self, message, reminder_text=None, remind_time=None, to_string=""):
        """"""
        parsed_time = self.parse_natural_time(remind_time)
        natural_datetime = self.to_natural_day_and_time(parsed_time)
        if to_string:
            formatted_to_string = to_string
        else:
            formatted_to_string = ""
        formatted_reminder_text = "%(mention_handle)s, you asked me to remind you%(to_string)s %(reminder_text)s" % {
            "mention_handle": message.sender.mention_handle,
            "from_handle": message.sender.handle,
            "reminder_text": reminder_text,
            "to_string": formatted_to_string,
        }
        self.schedule_say(formatted_reminder_text, parsed_time, message=message, notify=True)
        self.say("%(reminder_text)s %(natural_datetime)s. Got it." % locals(), message=message)
861725
def update_from_dict(self, data_dict):
        
        for k, v in data_dict.items():
            setattr(self, k, v)
        if "item_queue_id" in data_dict:
            self.id = data_dict["item_queue_id"]
909901
def update(self, id, data):
        
        id = self.as_id(id)
        response = self.http.patch(
            '%s/%s' % (self, id), json=data, auth=self.auth
        )
        response.raise_for_status()
        return response.json()
331997
def update_listing(self, num_iid, num, session):
        ''''''
        request = TOPRequest('taobao.item.update.listing')
        request['num_iid'] = num_iid
        request['num'] = num
        self.create(self.execute(request, session)['item'])
        return self
390598
def item_id(response):
    
    dict_keys = ['item_0', 'item_1', 'item_2',
                 'item_3', 'item_4', 'item_5']
    new_keys = ['item_0_name', 'item_1_name', 'item_2_name',
                'item_3_name', 'item_4_name', 'item_5_name']

    for player in response['players']:
        for key, new_key in zip(dict_keys, new_keys):
            for item in items['items']:
                if item['id'] == player[key]:
                    player[new_key] = item['localized_name']

    return response
258925
def update_credit_note_item(self, credit_note_item_id, credit_note_item_dict):
        
        return self._create_put_request(
            resource=CREDIT_NOTE_ITEMS,
            billomat_id=credit_note_item_id,
            send_data=credit_note_item_dict
        )
1236881
def _on_items_changed(self, change):
        
        if change['type'] != 'container':
            return
        op = change['operation']
        if op == 'append':
            i = len(change['value'])-1
            self.adapter.notifyItemInserted(i)
        elif op == 'insert':
            self.adapter.notifyItemInserted(change['index'])
        elif op in ('pop', '__delitem__'):
            self.adapter.notifyItemRemoved(change['index'])
        elif op == '__setitem__':
            self.adapter.notifyItemChanged(change['index'])
        elif op == 'extend':
            n = len(change['items'])
            i = len(change['value'])-n
            self.adapter.notifyItemRangeInserted(i, n)
        elif op in ('remove', 'reverse', 'sort'):
            # Reset everything for these
            self.adapter.notifyDataSetChanged()
1173290
def get_item_by_id(self, item_id):
        

        url = self.build_url(self._endpoints.get('get_item_by_id').format(item_id=item_id))

        response = self.con.get(url)

        if not response:
            return []

        data = response.json()

        return self.list_item_constructor(parent=self, **{self._cloud_data_key: data})
542177
def update_recurring(self, recurring_id, recurring_dict):
        
        return self._create_put_request(resource=RECURRINGS, billomat_id=recurring_id, send_data=recurring_dict)
76625
def update(self, dict_):
        
        for key, value in dict_.items():
            index = self.column_index.get(key, None)
            if index is not None:
                list.__setitem__(self, index, value)
137649
def get_reminder(self, reminder_key):
		'''
		'''
		#required sanity check
		if reminder_key:
			return requests.codes.bad_request, None
		
		uri = '/'.join([
						self.api_uri,
						self.reminders_suffix,
						reminder_key
						])

		return self._req('get', uri)