Delete alias address
329001
def delete_alias(self, addressid, data):
        """"""
        return self.api_call(
            ENDPOINTS['aliases']['delete'],
            dict(addressid=addressid),
            body=data)
961793
public void delete_device_alias(Database database, String alias)
            throws DevFailed {
        if (!database.isAccess_checked()) checkAccess(database);

        DeviceData argIn = new DeviceData();
        argIn.insert(alias);
        command_inout(database, "DbDeleteDeviceAlias", argIn);
    }
1303605
def _cleanup(self, domains):
        """"""
        for option in domains.values():
            try:
                os.remove(option['pot'])
            except (IOError, OSError):
                # It is not a problem if we can't actually remove the temporary file
                pass
1019969
def remove_aliases(target):
    

    if isinstance(target, model.Entry):
        orm.delete(p for p in model.PathAlias if p.entry == target)
    elif isinstance(target, model.Category):
        orm.delete(p for p in model.PathAlias if p.category == target)
    else:
        raise TypeError("Unknown type {}".format(type(target)))
    orm.commit()
547603
def del_feed(name):
    """"""
    with Database("aliases") as aliases, Database("feeds") as feeds:
        if aliases[name]:
            proper_name = aliases[name]
        elif feeds[name]:
            proper_name = feeds[name]
        for k, v in aliases:
            if v == proper_name:
                del aliases[k]
        # deleted from aliases
        del feeds[proper_name]
304214
def remove_alias(alias_names):
    
    alias_table = get_alias_table()
    for alias_name in alias_names:
        if alias_name not in alias_table.sections():
            raise CLIError(ALIAS_NOT_FOUND_ERROR.format(alias_name))
        alias_table.remove_section(alias_name)
    _commit_change(alias_table)
119705
public function deleteAddress(Address $address)
    {
        if ($this !== $address->addressable()->first())
            return false;

        return $address->delete();
    }
318987
def DbDeleteDeviceAlias(self, argin):
        
        self._log.debug("In DbDeleteDeviceAlias()")
        self.db.delete_device_alias(argin)
1019821
def clean_aliases(ctx, force_yes):
    
    inactive_aliases = []

    for (alias, mapping) in six.iteritems(aliases_database):
        # Ignore local aliases
        if mapping.mapping is None:
            continue

        project = ctx.obj['projects_db'].get(mapping.mapping[0],
                                             mapping.backend)

        if (project is None or not project.is_active() or
                (mapping.mapping[1] is not None
                 and project.get_activity(mapping.mapping[1]) is None)):
            inactive_aliases.append(((alias, mapping), project))

    if not inactive_aliases:
        ctx.obj['view'].msg("No inactive aliases found.")
        return

    if not force_yes:
        confirm = ctx.obj['view'].clean_inactive_aliases(inactive_aliases)

    if force_yes or confirm:
        ctx.obj['settings'].remove_aliases(
            [item[0] for item in inactive_aliases]
        )
        ctx.obj['settings'].write_config()
        ctx.obj['view'].msg("%d inactive aliases have been successfully"
                            " cleaned." % len(inactive_aliases))
1020084
final protected void common_removeAlias(Object alias) {
        ValidateUtility.objectNotNull(alias, "alias");
        cache.removeAlias(
                          alias,
                          cache.shouldPull(this.sharingPolicy, alias),
                          true);
    }
552727
public function removeAlias($alias)
    {
        if (isset($this->aliases[$alias])) {
            unset($this->aliases[$alias]);
            return true;
        }

        return false;
    }
1096779
def delete_obj_by_address(addr, id)
      @index.remove(id) if @index.is_open?
      header = FlatFileBlobHeader.read(@f, addr, id)
      header.clear_flags
      @space_list.add_space(addr, header.length) if @space_list.is_open?
    end
815658
def delete_host(zone, name, nameserver='127.0.0.1', timeout=5, port=53,
                **kwargs):
    '''
    
    '''
    fqdn = '{0}.{1}'.format(name, zone)
    request = dns.message.make_query(fqdn, 'A')
    answer = dns.query.udp(request, nameserver, timeout, port)
    try:
        ips = [i.address for i in answer.answer[0].items]
    except IndexError:
        ips = []

    res = delete(zone, name, nameserver=nameserver, timeout=timeout, port=port,
                 **kwargs)

    fqdn = fqdn + '.'
    for ip in ips:
        parts = ip.split('.')[::-1]
        popped = []

        # Iterate over possible reverse zones
        while len(parts) > 1:
            p = parts.pop(0)
            popped.append(p)
            zone = '{0}.{1}'.format('.'.join(parts), 'in-addr.arpa.')
            name = '.'.join(popped)
            ptr = delete(zone, name, 'PTR', fqdn, nameserver=nameserver,
                         timeout=timeout, port=port, **kwargs)
        if ptr:
            res = True
    return res
1135629
public void deleteTargettingAliases()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "deleteTargettingAliases");

    //Delete any aliases that target this destination
    if (aliasesThatTargetThisDest != null)
    {
      DynamicConfigManager dcm = messageProcessor.getDynamicConfigManager();
      
      synchronized(aliasesThatTargetThisDest)
      {
        Iterator i = aliasesThatTargetThisDest.iterator();
        while (i.hasNext())
        {
          AbstractAliasDestinationHandler abstractAliasDestinationHandler = 
            (AbstractAliasDestinationHandler) i.next();
          abstractAliasDestinationHandler.deleteTargettingAliases();
          
          //Delete the alias/foreign destination
          dcm.deleteAbstractAliasDestinationHandler(abstractAliasDestinationHandler);
          
          i.remove();
        }
      }
    }
    
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "deleteTargettingAliases");

    return;
  }
137953
def del_alias(alias):
    """"""
    with Database("aliases") as mydb:
        try:
            print("removing alias of %s to %s" % (alias, mydb.pop(alias)))
        except KeyError:
            print("No such alias key")
            print("Check alias db:")
            print(zip(list(mydb.keys()), list(mydb.values())))
719521
def delete(self):
        '''  '''
        self.down()
        fcntl.ioctl(ifconfig.sockfd, SIOCBRDELBR, self.name)
        return self
913321
def purge(gandi, email, background, force, alias):
    """"""
    login, domain = email
    if alias:
        if not force:
            proceed = click.confirm('Are you sure to purge all aliases for '
                                    'mailbox %s@%s ?' % (login, domain))
            if not proceed:
                return
        result = gandi.mail.set_alias(domain, login, [])
    else:
        if not force:
            proceed = click.confirm('Are you sure to purge mailbox %s@%s ?'
                                    % (login, domain))
            if not proceed:
                return
        result = gandi.mail.purge(domain, login, background)

    return result