Removes the license.

        raise:  NoAccess - ``Metadata.isRequired()`` is ``true`` or
                ``Metadata.isReadOnly()`` is ``true``
        *compliance: mandatory -- This method must be implemented.*
330997
def clear_license(self):
        
        if (self.get_license_metadata().is_read_only() or
                self.get_license_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['license'] = dict(self._license_default)
769716
def remove(self, source: Source) -> None:
        
        self.unload(source)
        if isinstance(source, RemoteSource):
            shutil.rmtree(source.location, ignore_errors=True)
        self.save()
1001851
def remove(self, rel_path, propagate=False):
        ''''''

        if not self.upstream:
            raise Exception("Must have an upstream")

        # Must always propagate, since this is really just a filter.
        self.upstream.remove(self._rename(rel_path), propagate)
515815
def delete_reference(self, opaque_ref, global_ref=False):
        
        opaque_ref_value = self._get_reference_value(opaque_ref)
        if global_ref:
            del self.global_refs[opaque_ref_value]
        else:
            del self.local_refs[opaque_ref_value]
1248990
def remove(self, metric_producer):
        
        if metric_producer is None:
            raise ValueError
        try:
            with self.mp_lock:
                self.metric_producers.remove(metric_producer)
        except KeyError:
            pass
162444
def Delete(self):
		

		self.public_ip.source_restrictions = [o for o in self.public_ip.source_restrictions if o!=self]

		return(self.public_ip.Update())
396525
def removeProdable(self, prodable: Prodable=None, name: str=None) -> Optional[Prodable]:
        
        if prodable:
            self.prodables.remove(prodable)
            return prodable
        elif name:
            for p in self.prodables:
                if hasattr(p, "name") and getattr(p, "name") == name:
                    prodable = p
                    break
            if prodable:
                self.prodables.remove(prodable)
                return prodable
            else:
                logger.warning("Trying to remove a prodable {} which is not present"
                               .format(prodable))
        else:
            logger.error("Provide a prodable object or a prodable name")
952581
def check_license(self):
        

        opts = self.distribution.get_option_dict('metadata')

        # ignore the source of the value
        _, license_file = opts.get('license_file', (None, None))

        if license_file is None:
            log.debug("'license_file' option was not specified")
            return

        if not os.path.exists(license_file):
            log.warn("warning: Failed to find the configured license file '%s'",
                    license_file)
            return

        self.filelist.append(license_file)
1240577
def clear_copyright_registration(self):
        
        # Implemented from template for osid.repository.AssetContentForm.clear_url_template
        if (self.get_copyright_registration_metadata().is_read_only() or
                self.get_copyright_registration_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['copyrightRegistration'] = self._copyright_registration_default
243784
def remove_parameter(self, name):
		
		spec = self.__specs[name] if name in self.__specs else None
		if spec is not None and spec.optional() is False:
			raise ValueError('Unable to remove a required parameter "%s"' % name)

		WURIQuery.remove_parameter(self, name)
810580
def quit(self, *args, **kwargs):  # real signature unknown
        
        self._stop = True
        super(ReadProbes, self).quit(*args, **kwargs)
475156
def unregister(self, name):
        
        try:
            name = name.name
        except AttributeError:
            pass
        return self.pop(name,None)
458518
def unregister(self):
        """"""
        self.names.remove(self.uniquename)
        super(ConfigurableMeta, self).unregister()
409339
def unregister(self, alias):
        
        if alias not in self._service_objects:
            raise Error(self._device,
                        'No service is registered with alias "%s".' % alias)
        service_obj = self._service_objects.pop(alias)
        if service_obj.is_alive:
            with expects.expect_no_raises(
                    'Failed to stop service instance "%s".' % alias):
                service_obj.stop()
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 = ""
256497
def remove(self, force=False):
        
        if force:
            _fs, filename = opener.parse(self.uri)
            _fs.remove(filename)
        self.uri = None
638404
def unregisterAPI(self, name):
        
        if name.startswith('public/'):
            target = 'public'
            name = name[len('public/'):]
        else:
            target = self.servicename
            name = name
        removes = [m for m in self.handler.handlers.keys() if m.target == target and m.name == name]
        for m in removes:
            self.handler.unregisterHandler(m)