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

        Overload to handle formatting of ipv6 addresses

        Args:
            data (string): The indicator value
342004
def indicator(self, data):
        
        try:
            ip = ipaddress.ip_address(data)
        except ValueError:
            ip = ipaddress.ip_address(u'{}'.format(data))
        if ip.version == 6:
            data = ip.exploded
            sections = []
            # mangle perfectly good ipv6 address to match TC format
            for s in data.split(':'):
                if s == '0000':
                    s = '0'
                else:
                    s = s.lstrip('0')
                sections.append(s)
            data = ':'.join(sections)
        super(Address, self).indicator(data)
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)
961991
def _loadData(self, data):
        
        self._data = data
        for elem in data:
            id = utils.lowerFirst(elem.attrib['id'])
            if id in self._settings:
                self._settings[id]._loadData(elem)
                continue
            self._settings[id] = Setting(self._server, elem, self._initpath)
957314
def request_param_update(self, var_id):
        """"""
        self._useV2 = self.cf.platform.get_protocol_version() >= 4
        pk = CRTPPacket()
        pk.set_header(CRTPPort.PARAM, READ_CHANNEL)
        if self._useV2:
            pk.data = struct.pack('<H', var_id)
        else:
            pk.data = struct.pack('<B', var_id)
        logger.debug('Requesting request to update param [%d]', var_id)
        self.request_queue.put(pk)
639417
def Update(self, data):
        
        m = len(data)
        self.params[:m] += data
691682
public static base_response update(nitro_service client, onlinkipv6prefix resource) throws Exception {
		onlinkipv6prefix updateresource = new onlinkipv6prefix();
		updateresource.ipv6prefix = resource.ipv6prefix;
		updateresource.onlinkprefix = resource.onlinkprefix;
		updateresource.autonomusprefix = resource.autonomusprefix;
		updateresource.depricateprefix = resource.depricateprefix;
		updateresource.decrementprefixlifetimes = resource.decrementprefixlifetimes;
		updateresource.prefixvalidelifetime = resource.prefixvalidelifetime;
		updateresource.prefixpreferredlifetime = resource.prefixpreferredlifetime;
		return updateresource.update_resource(client);
	}
1281781
def update_format(self, format):
        
        self.format = format
        self.request.update(format=self.format.data)
1267924
def load(self, data):
        
        self.clear()
        self.update(data)
        self.enhance()
987817
def querystring_update(request, **kwargs):
    
    updated = request.GET.copy()
    for k, v in kwargs.items():
        updated[k] = v

    return updated.urlencode()
5419
def indication(self, pdu):
        """"""
        if _debug: TCPServer._debug("indication %r", pdu)

        self.request += pdu.pduData
473089
def update(self, ip):
        """"""
        timeout = 60
        LOG.debug("Updating '%s' to '%s' at service '%s'", self.hostname, ip, self._updateurl)
        params = {"domains": self.hostname.partition(".")[0], "token": self.__token}
        if ip is None:
            params["ip"] = ""
        else:
            params["ip"] = ip
        # LOG.debug("Update params: %r", params)
        req = requests.get(self._updateurl, params=params, headers=constants.REQUEST_HEADERS_DEFAULT,
                           timeout=timeout)
        LOG.debug("status %i, %s", req.status_code, req.text)
        # duckdns response codes seem undocumented...
        if req.status_code == 200:
            if req.text.startswith("OK"):
                return ip
            return req.text
        return "invalid http status code: %s" % req.status_code
1179865
def update(self, data):
        
        try:
            self.verifier.update(data)
        except TypeError:
            log.error("Invalid data: {} ({})".format(type(data), data))
            raise
990765
def __updateDataItem(self):
        """"""
        uri = self.getUri()        
        self.__dataItem = self.__parseResponseServer(uri)
433779
def applies_to(self, url_data):
        """"""
        return url_data.valid and url_data.scheme == 'https' and \
          not url_data.extern[0] and url_data.url_connection is not None
237677
def update(self, update):
        

        params = shlex.split(update)
        if params[0] in self.addr:
            self.addr[params[0]].update(*params)

        else:
            a = Addr(self)
            # add both name and IP address
            self.addr[params[0]] = a
            self.addr[params[1]] = a
            a.update(*params)
            self.notify("addrmap_added", *[a], **{})
25887
def patch(self, url, data=None, params=None):
        
        return self.request("patch", url, data, params)
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)