Update the request URI to include the Indicator for specific indicator retrieval.

        Args:
            data (string): The indicator value
558828
def indicator(self, data):
        
        # handle hashes in form md5 : sha1 : sha256
        data = self.get_first_hash(data)
        super(File, self).indicator(data)
970283
def update(self):
        '''
        
        '''
        conditionalRequestHeader = dict()
        if self.etag is not None:
            conditionalRequestHeader[Consts.REQ_IF_NONE_MATCH] = self.etag
        if self.last_modified is not None:
            conditionalRequestHeader[Consts.REQ_IF_MODIFIED_SINCE] = self.last_modified

        status, responseHeaders, output = self._requester.requestJson(
            "GET",
            self._url.value,
            headers=conditionalRequestHeader
        )
        if status == 304:
            return False
        else:
            headers, data = self._requester._Requester__check(status, responseHeaders, output)
            self._storeAndUseAttributes(headers, data)
            self.__completed = True
            return True
1304363
def update_source(ident, data):
    ''''''
    source = get_source(ident)
    source.modify(**data)
    signals.harvest_source_updated.send(source)
    return source
1304012
def set_request(self, r):
        
        for k in self.environments.keys():
            self.environments[k].globals['REQUEST'] = r
347987
def add_request(self, request):
        

        # Duplicate request name?
        if request.name in self.requests:
            raise ValueError('redefinition of request "{0}"'.format(request.name))
        self.requests[request.name] = request

        # Add the request URLs
        for method, url in request.urls:

            # URL with arguments?
            if RE_URL_ARG.search(url):
                request_regex = '^' + RE_URL_ARG_ESC.sub(r'/(?P<\1>[^/]+)', re.escape(url)) + '$'
                self.__request_regex.append((method, re.compile(request_regex), request))
            else:
                request_key = (method, url)
                if request_key in self.__request_urls:
                    raise ValueError('redefinition of request URL "{0}"'.format(url))
                self.__request_urls[request_key] = request
706233
def send_update(url_id, dataset):
    
    data = _convert_to_seeder_format(dataset)

    if not data:
        return

    try:
        _send_request(url_id, json=data, req_type=requests.patch)
    except Exception as e:
        sys.stderr.write("Seeder PATCH error: ")  # TODO: better!
        sys.stderr.write(str(e.message))
        return None
779907
def _load_11_5_4(self, **kwargs):
        
        if 'uri' in self._meta_data:
            error = "There was an attempt to assign a new uri to this " \
                    "resource, the _meta_data['uri'] is %s and it should" \
                    " not be changed." % (self._meta_data['uri'])
            raise URICreationCollision(error)
        requests_params = self._handle_requests_params(kwargs)
        self._check_load_parameters(**kwargs)
        kwargs['uri_as_parts'] = True
        refresh_session = self._meta_data['bigip']._meta_data[
            'icr_session']
        base_uri = self._meta_data['container']._meta_data['uri']
        kwargs.update(requests_params)
        for key1, key2 in self._meta_data['reduction_forcing_pairs']:
            kwargs = self._reduce_boolean_pair(kwargs, key1, key2)
        kwargs = self._check_for_python_keywords(kwargs)
        try:
            response = refresh_session.get(base_uri, **kwargs)
        except HTTPError as err:
            if err.response.status_code != 404:
                raise
            if err.response.status_code == 404:
                return self._return_object(self._meta_data['container'],
                                           kwargs['name'])
        # Make new instance of self
        return self._produce_instance(response)
876067
def update(self, data):
        
        if not data:
            return
        _rk, _dumps = self.get_key, self._dumps
        data = self._client.mset({
            _rk(key): _dumps(value)
            for key, value in data.items()})
1139584
def update(self, data):
        
        self.debug(data)
        self._check(data)
        wg_uuid = data.get('workGroup')
        self.log.debug("wg_uuid : %s ", wg_uuid)
        uuid = data.get('uuid')
        url = "%(base)s/%(wg_uuid)s/nodes/%(uuid)s" % {
            'base': self.local_base_url,
            'wg_uuid': wg_uuid,
            'uuid': uuid
        }
        return self.core.update(url, data)
606964
def setData(self, data):
        
        try:
            bytestream = pickle.dumps(data)
            super(MimeData, self).setData(self._mimeType, bytestream)
        except TypeError:
            raise TypeError(self.tr("can not pickle added data"))
        except:
            raise
309622
def update(request)
      begin
        data = request.params['data']
        hash = RackSessionAccess.decode(data)
        hash.each { |k, v| request.env[@key][k] = v }
      rescue => e
        return render(400) do |xml|
          xml.h2("Bad data #{data.inspect}: #{e.message} ")
        end
      end

      redirect_to action_path(:show)
    end
1002230
def update_uris(self, new_uri):
        
        self.uri = new_uri

        # if there is a sub-service, update it too
        if self.obj:
            self.obj.base_url = '{0}/{1}'.format(self.uri, self.service_name)
210581
def post(self, uri, data, **kwargs):
        
        return self.request("POST", uri, data=data, **kwargs)
1297397
def Update(self, data):
        
        for hypo in self.Values():
            like = self.Likelihood(data, hypo)
            self.Mult(hypo, like)
        self.Normalize()
289082
def _update(self, uri, body, **kwargs):
        
        self.run_hooks("modify_body_for_update", body, **kwargs)
        resp, resp_body = self.api.method_put(uri, body=body)
        return resp_body
261808
def add_data(self, data):
        

        if self.data_size - self.data_index < len(data):
            return Error.DESTINATION_BUFFER_TOO_SMALL

        if self.in_progress is not None:
            self.in_progress.data += data

        return Error.NO_ERROR
5598
def update
      url = single_url
      payload = attributes_to_payload
      payload[:reset_data] = true
      to_server url, payload
    end