Delete this source restriction and commit change to cloud.

		>>> clc.v2.Server("WA1BTDIX01").PublicIPs().public_ips[0].source_restrictions[0].Delete().WaitUntilComplete()
		0
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())
678749
def destroy(self):
        
        if not hasattr(self, 'server') or not self.server:
            raise Exception(
                """FirewallRule not associated with server;
                please use or server.get_firewall_rules() to get objects
                that are associated with a server.
                """)
        return self.server.cloud_manager.delete_firewall_rule(
            self.server.uuid,
            self.position
        )
1141235
def delete(self, network):
        
        try:
            return super(CloudNetworkClient, self).delete(network)
        except exc.Forbidden as e:
            # Network is in use
            raise exc.NetworkInUse("Cannot delete a network in use by a server.")
1296001
def delete(self):
        
        try:
            return super(CloudNetwork, self).delete()
        except exc.Forbidden as e:
            # Network is in use
            raise exc.NetworkInUse("Cannot delete a network in use by a server.")
159160
public OperationFuture<Server> removePublicIp(Server serverRef, String ipAddress) {
        checkNotNull(ipAddress, "ipAddress must be not null");

        Link response = client.removePublicIp(idByRef(serverRef), ipAddress);

        return new OperationFuture<>(
            serverRef,
            response.getId(),
            queueClient
        );
    }
435485
public void removeSubscribedSource(Source source) {
        String sourceId = CollectorManagerUtils.getSourceId(source);
        subscribedSources.remove(sourceId);
    }
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)
455062
def remove_service(self, wait_timeout=10, sleep_wait=1):
        '''
        
        '''

        # Stops/remove the PAExec service and removes the executable
        log.debug("Deleting PAExec service at the end of the process")
        wait_start = time.time()
        while True:
            try:
                self._client._service.delete()
            except SCMRException as exc:
                log.debug("Exception encountered while deleting service %s", repr(exc))
                if time.time() - wait_start > wait_timeout:
                    raise exc
                time.sleep(sleep_wait)
                continue
            break

        # delete the PAExec executable
        smb_tree = TreeConnect(
            self._client.session,
            r"\\{0}\ADMIN$".format(self._client.connection.server_name)
        )
        log.info("Connecting to SMB Tree %s", smb_tree.share_name)
        smb_tree.connect()

        wait_start = time.time()
        while True:
            try:
                log.info("Creating open to PAExec file with delete on close flags")
                self._client._delete_file(smb_tree, self._exe_file)
            except SMBResponseException as exc:
                log.debug("Exception deleting file %s %s", self._exe_file, repr(exc))
                if time.time() - wait_start > wait_timeout:
                    raise exc
                time.sleep(sleep_wait)
                continue
            break
        log.info("Disconnecting from SMB Tree %s", smb_tree.share_name)
        smb_tree.disconnect()
74418
def delete_cloud_obj(self, cloud_obj):
        
        self._connection.delete_object(
            container=self.container_name,
            obj=cloud_obj,
        )
579869
public PublicIpRequest sourceRestrictions(List<String> sourceRestrictions) {
        List<SourceRestriction> restrictions = new ArrayList<>(sourceRestrictions.size());
        sourceRestrictions.forEach(value -> restrictions.add(new SourceRestriction(value)));
        setSourceRestrictions(restrictions);
        return this;
    }
640131
def delete_fallbackserver(self, serverid, data):
        """"""
        return self.api_call(
            ENDPOINTS['fallbackservers']['delete'],
            dict(serverid=serverid),
            body=data)
1062620
def delete(gandi, resource, background, force):
    
    resource = sorted(tuple(set(resource)))
    possible_resources = gandi.ip.resource_list()

    # check that each IP can be deleted
    for item in resource:
        if item not in possible_resources:
            gandi.echo('Sorry interface %s does not exist' % item)
            gandi.echo('Please use one of the following: %s' %
                       possible_resources)
            return

    if not force:
        proceed = click.confirm('Are you sure you want to delete ip(s) %s' %
                                ', '.join(resource))
        if not proceed:
            return

    return gandi.ip.delete(resource, background, force)
435673
def source_delete(source):
    '''
    
    '''
    ret = {}
    cmd = 'imgadm sources -d {0}'.format(source)
    res = __salt__['cmd.run_all'](cmd)
    retcode = res['retcode']
    if retcode != 0:
        ret['Error'] = _exit_status(retcode, res['stderr'])
        return ret

    return sources(False)
573134
def unpublish(self, daap_server):
        

        if daap_server not in self.daap_servers:
            return

        self.zeroconf.unregister_service(self.daap_servers[daap_server])

        del self.daap_servers[daap_server]
302496
@Override
    public void close() {
        try {
            if (clientSidePolicy != null) {
                clientSidePolicy.removePropertyChangeListener(this);
            }

        } finally {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "Finished servicing http request on conduit. ");
            }
            //clean up address within threadlocal of EndPointInfo
            endpointInfo.resetAddress();    //Liberty #3669
        }

    }
1205064
def delete(method, hmc, uri, uri_parms, logon_required):
        """"""
        try:
            hba = hmc.lookup_by_uri(uri)
        except KeyError:
            raise InvalidResourceError(method, uri)
        partition = hba.manager.parent
        cpc = partition.manager.parent
        assert cpc.dpm_enabled
        check_valid_cpc_status(method, uri, cpc)
        check_partition_status(method, uri, partition,
                               invalid_statuses=['starting', 'stopping'])

        partition.hbas.remove(hba.oid)
668576
def Update(self):
		

		return(clc.v2.Requests(clc.v2.API.Call('PUT','servers/%s/%s/publicIPAddresses/%s' % (self.parent.server.alias,self.parent.server.id,self.id),
						                       json.dumps({'ports': [o.ToDict() for o in self.ports],
											               'sourceRestrictions': [o.ToDict() for o in self.source_restrictions] }),
											   session=self.session),
							   alias=self.parent.server.alias,
							   session=self.session))