Edits a customer by ID. All fields available at creation can be updated
        as well. If you want to update hourly rates retroactively, set the
        argument `update_hourly_rate_on_time_entries` to True.
342760
def edit_customer(self, id_, **kwargs):
        
        data = self._wrap_dict("customer", kwargs)
        return self.patch("/customers/{}.json".format(id_), data=data)
587737
def update_customer(self, customer_id, customer_deets):
        """"""
        request = self._put("customers/" + str(customer_id), customer_deets)
        return self.responder(request)
1309558
def _add_updated_at_column(self, values):
        
        if not self._model.uses_timestamps():
            return values

        column = self._model.get_updated_at_column()

        if "updated_at" not in values:
            values.update({column: self._model.fresh_timestamp_string()})

        return values
31938
def update(request)
      timestamp = request.first(options[:field])
      @hour_frequencies[timestamp.to_s[8..9].to_i] += 1
      @first = timestamp if timestamp < @first
      @last  = timestamp if timestamp > @last
    end
720722
static function setIsValid( $id, $isValid )
    {
        $dateTime = time();
        $isValid = (int) $isValid;
        eZPersistentObject::updateObjectList( array( 'definition' => eZURL::definition(),
                                                     'update_fields' => array( 'is_valid' => $isValid,
                                                                               'modified' => $dateTime ),
                                                     'conditions' => array( 'id' => $id ) ) );
    }
74395
def edit_project(self, id_, **kwargs):
        
        data = self._wrap_dict("project", kwargs)
        return self.patch("/projects/{}.json".format(id_), data=data)
1371726
def set_updated_at
      if Dynamoid::Config.timestamps && !updated_at_changed?
        self.updated_at = DateTime.now.in_time_zone(Time.zone)
      end
    end
1289709
def update(self, request, id):
        """"""
        try:
            object = self.model.objects.get(id=id)
        except self.model.DoesNotExist:
            return self._render(
                request = request,
                template = '404',
                context = {
                    'error': 'The %s could not be found.' % self.model.__name__.lower()
                },
                status = 404,
                prefix_template_path = False
            )

        fields = []
        for field in request.PATCH:

            try:
                self.model._meta.get_field_by_name(field)
            except FieldDoesNotExist:
                continue
            else:
                fields.append(field)

        Form = generate_form(
            model = self.model,
            form = self.form,
            fields = fields
        )

        form = Form(request.PATCH, instance=object)
        if form.is_valid():
            object = form.save()

            return self.show(request, id)
        else:
            return self._render(
                request = request,
                template = 'edit',
                context = {
                    'form': form
                },
                status = 400
            )
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()
819610
def update_fields(fields)
      attributes[:action_id]          = fields['id'] || attributes[:action_id]
      attributes[:text]               = fields['data']['text'] || attributes[:text]
      attributes[:date]               = Time.iso8601(fields['date']) if fields.has_key?('date')
      attributes[:member_creator_id]  = fields['idMemberCreator'] || attributes[:member_creator_id]
      self
    end
1063289
def update_client(self, client_id, client_dict):
        
        return self._create_put_request(
            resource=CLIENTS,
            billomat_id=client_id,
            send_data=client_dict
        )
203121
def update(self, typ, id, **kwargs):
        
        return self._load(self._request(typ, id=id, method='PUT', data=kwargs))
981986
def update_attribute!(attribute, value, should_reload_attributes = true)
      execute_and_capture_raises_at_errors(204) do
        @last_response = Http.patch("/charge-accounts/#{uuid}/", domain.token, etag, attribute => value)
      end
      
      reload_attributes! if should_reload_attributes
    end
348787
def update(attributes)
      warn "[DEPRECATED] update as an instance method is deprecated. Please use Address.update"
      result = @gateway.address.update(customer_id, id, attributes)
      if result.success?
        copy_instance_variables_from_object result.address
      end
      result
    end
316415
async def update(cls, access_key: str,
                     is_active: bool = None,
                     is_admin: bool = None,
                     resource_policy: str = None,
                     rate_limit: int = None) -> dict:
        
        q = 'mutation($access_key: String!, $input: ModifyKeyPairInput!) {' + \
            '  modify_keypair(access_key: $access_key, props: $input) {' \
            '    ok msg' \
            '  }' \
            '}'
        variables = {
            'access_key': access_key,
            'input': {
                'is_active': is_active,
                'is_admin': is_admin,
                'resource_policy': resource_policy,
                'rate_limit': rate_limit,
            },
        }
        rqst = Request(cls.session, 'POST', '/admin/graphql')
        rqst.set_json({
            'query': q,
            'variables': variables,
        })
        async with rqst.fetch() as resp:
            data = await resp.json()
            return data['modify_keypair']
767742
def update_rates(self):
        
        source, created = RateSource.objects.get_or_create(name=self.get_source_name())
        source.base_currency = self.get_base_currency()
        source.save()

        for currency, value in six.iteritems(self.get_rates()):
            try:
                rate = Rate.objects.get(source=source, currency=currency)
            except Rate.DoesNotExist:
                rate = Rate(source=source, currency=currency)

            rate.value = value
            rate.save()
1253167
def update(client_id, key, value)
      @clients.each do |hash|
        if hash[:client_id] == client_id
          hash[key] = value
        end
      end
    end