Removes the url.

        raise:  NoAccess - ``Metadata.isRequired()`` is ``true`` or
                ``Metadata.isReadOnly()`` is ``true``
        *compliance: mandatory -- This method must be implemented.*
554536
def clear_url(self):
        
        # Implemented from template for osid.repository.AssetContentForm.clear_url_template
        if (self.get_url_metadata().is_read_only() or
                self.get_url_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['url'] = self._url_default
88440
def delete(method, hmc, uri, uri_parms, logon_required):
        """"""
        try:
            resource = hmc.lookup_by_uri(uri)
        except KeyError:
            raise InvalidResourceError(method, uri)
        resource.manager.remove(resource.oid)
1010169
def delete_resource(uri)
      clear
      uri = URI.parse(uri)
      @req = Net::HTTP::Delete.new uri.request_uri
      set_common_info(@req)
      @http_class.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|
        @res = http.request(@req)
        case @res
          when Net::HTTPSuccess
            #warn "Bad Status Code: #{@res.code}" unless @res.class == Net::HTTPOK || @res.class == Net::HTTPNoContent
          else
            raise RequestError, "Failed to delete resource. #{@res.code}"
          end
      end
    end
704075
def removeGuideline(self, guideline):
        
        if isinstance(guideline, int):
            index = guideline
        else:
            index = self._getGuidelineIndex(guideline)
        index = normalizers.normalizeIndex(index)
        if index >= self._len__guidelines():
            raise ValueError("No guideline located at index %d." % index)
        self._removeGuideline(index)
1057412
def _delete(self, url, **kwargs):
        

        response = retry_request(self)(self._http_delete)(url, **kwargs)

        if self.raw_mode:
            return response

        if response.status_code >= 300:
            error = get_error(response)
            if self.raise_errors:
                raise error
            return error

        return response
614183
def _delete(self, url):
        """"""
        r = requests.delete(self._api_prefix + url,
            headers=self.headers,
            auth=self.auth,
            allow_redirects=False,
        )
        return self._action(r)
346353
def delete(self):
        
        if self.resource_uri is None:
            raise ValueError("{0} object cannot be deleted because resource_uri attribute cannot be None".format(self._meta.resource_name))

        self._meta.api.http_resource("DELETE", self.resource_uri)
546431
def delete_resource(self, uri, purge=False):
        
        try:
            resource = self.get_resource_by_uri(uri)
        except ResourceNotFoundError:
            # Nothing to remove
            return None

        if isinstance(resource, File):
            result = self.delete_file(uri, purge)
        elif isinstance(resource, Folder):
            result = self.delete_folder(uri, purge)
        else:
            raise ValueError('Unsupported resource: {}'.format(type(resource)))

        return result
1033564
def rest_del(self, url, params=None, session=None, verify=True, cert=None):
        
        res = session.delete(url, params=params, verify=verify, cert=cert)
        return res.text, res.status_code
1158646
def clear_title(self):
        
        metadata = Metadata(**settings.METADATA['title'])
        if metadata.is_read_only() or metadata.is_required():
            raise NoAccess()
        self._my_map['title']['text'] = ''
1196668
def delete(self, uri):
        
        try:
            self.connect(uri, method='DELETE')
            return True
        except urllib.error.HTTPError:
            return False
961921
def remove_password_from_url(url):
    # type: (S) -> S
    

    parsed = _get_parsed_url(url)
    if parsed.auth:
        auth, _, _ = parsed.auth.partition(":")
        return parsed._replace(auth="{auth}:----".format(auth=auth)).url
    return parsed.url
581835
def remove_api_key(self):
        
        url = self.record_url + "/remove_api_key"
        res = requests.patch(url=url, headers=HEADERS, verify=False)
        res.raise_for_status()
        self.api_key = ""
112358
def delete(self, endpoint, **kwargs):
        
        kwargs.update(self.kwargs.copy())
        response = requests.delete(self.make_url(endpoint), **kwargs)
        return _decode_response(response)
806890
def _clean_url(self, url):
        
        # TODO: Turn this into regex
        if not url.startswith('http') or url.endswith('}}') or 'nojs_router' in url:
            return None
        if site(norm(url).lower()) in config.NONCANONIC_SITES:
            clean_url = canonicalize_url(url, keep_params=True)
        else:
            clean_url = canonicalize_url(url)
        return clean_url
75365
def _clean_item(self, request_url):
        
        del self._table[request_url]
        self._usage_recency.remove(request_url)
908088
synchronized void unregisterRequest(HttpRequest request) {
		assertTrue(this == request.requestManager);
		boolean removed = activeRequests.remove(request);
		assertTrue(removed, "Attempted to unregister missing request: %s", request);

		if (removed) {
			notifyRequestFinished(request);
		}
	}