is the given address on the don't send list?
332300
def has_address(self, address):
        
        queryset = self.filter(to_address__iexact=address)
        return queryset.exists()
480469
public function deleteEmailAddress(array $addresses = []): bool
    {
        $this->getApi()->request($this->getApi()->sprintf('/user/emails'), Request::METHOD_DELETE, $addresses);

        if ($this->getApi()->getHeaders()['Status'] == '204 No Content') {
            return true;
        }

        return false;
    }
980159
function notGetOrPost(tuple) {
        var v = tuple[0].toLowerCase()
        if (v === 'get') return false
        if (v === 'post') return false
        if (v === 'put') return false
        if (v === 'patch') return false
        if (v === 'delete') return false
        return true
      }
933029
public function emailsComeFromListOfApprovedSenders($emailAddress) {

        // are we checking that inbound emails come from a pre-approved list of senders?
        if (!$this->isInboundEmailsFromAllowedSendersOnly()) {

            // we are *not* checking that emails come from a pre-approved list of senders
            return true;
        }

        // yes, we are checking that emails come from a pre-approved list of senders
        if ($this->isInboundEmailsFromAllowedSendersOnlyListOfSsenders($emailAddress)) {

            // the sender is, indeed, on the list of pre-approved senders
            return true;
        }

        // the sender is not on the list of pre-approved senders
        return false;
    }
840953
def end_address(self):
        
        if self._instrs is []:
            return None

        return self._instrs[-1].address + self._instrs[-1].size - 1
768012
def parseAddress(address):
    
    parts = []
    parser = _AddressParser()
    end = parser(parts, address)
    if end != len(address):
        raise InvalidTrailingBytes()
    return parts[0]
879485
def _sent_without_response(self, send_time_before):
        """"""
        return not self._messages and self._send_time and self._send_time < send_time_before
979919
def isValidPublicAddress(address: str) -> bool:
    """"""
    valid = False

    if len(address) == 34 and address[0] == 'A':
        try:
            base58.b58decode_check(address.encode())
            valid = True
        except ValueError:
            # checksum mismatch
            valid = False

    return valid
170938
def clean_address(address):
    
    if isinstance(address, header.Header):
        return clean_address(address.encode('ascii'))

    elif isinstance(address, str):
        address = address.replace("<", "")
        address = address.replace(">", "")
        address = address.replace("\"", "")
        address = address.replace("\n", " ")
        address = address.replace("MAILER-DAEMON", "")
        address = address.lower().strip()

        email = None
        for word in address.split(' '):
            email_regex = re.compile(
                "^[a-zA-Z0-9._%-]+@[a-zA-Z0-9._%-]+.[a-zA-Z]{2,6}$"
                )
            email = re.match(email_regex, word)
            if email is not None:
                clean_email = email.group(0)
        if email is None:
            if address.split(' ')[-1].find('@') > -1:
                clean_email = address.split(' ')[-1].strip()
            elif address.split(' ')[-1].find('?') > -1:
                clean_email = 'n/a'
            else:
                clean_email = address

        return clean_email

    elif address is None:
        return None

    else:
        raise ValueError('An unexpected type was given to clean_address. Address was {}'.format(address))
        return None
543174
def packet_is_for_me(self, m):
        ''''''
        if m.target_system != self.master.mav.srcSystem:
            return False
        if m.target_component != self.master.mav.srcComponent:
            return False
        # if have a sender we can also check the source address:
        if self.sender is not None:
            if (m.get_srcSystem(), m.get_srcComponent()) != self.sender:
                return False
        return True
1350430
public void declineDefaultList() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
        // The request of the list is an privacy message with an empty list
        Privacy request = new Privacy();
        request.setDeclineDefaultList(true);

        // Send the package to the server
        setRequest(request);
    }
474665
function isInvalidInboundAddress(inboundAddress) {
    if (fuse.config.restrict_inbound === false)
      return false;

    return cleanAddress(inboundAddress) !== fuse.config.inbound_address;
  }
1257175
public void declineActiveList() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
        // The request of the list is an privacy message with an empty list
        Privacy request = new Privacy();
        request.setDeclineActiveList(true);

        // Send the package to the server
        setRequest(request);
    }
912649
public boolean isSuspect(String address) {
		for (NetworkAddress networkAddress : suspectNetworks) {
			if (networkAddress.isAddressInNetwork(address)) {
				return true;
			}
		}
		return false;
	}
524632
def is_occupied(self, address):
        

        idx = self._search(address)
        if len(self._list) <= idx:
            return False
        if self._list[idx].start <= address < self._list[idx].end:
            return True
        if idx > 0 and address < self._list[idx - 1].end:
            # TODO: It seems that this branch is never reached. Should it be removed?
            return True
        return False
9644
def exclude_ip_range(from, to)
      from_ip = IPAddr.new(from)
      to_ip   = IPAddr.new(to)
      (from_ip..to_ip)
      raise 'Invalid IP range specified' if (from_ip..to_ip).to_a.size.zero?
      @excluded_scan_targets[:addresses] << IPRange.new(from, to)
    rescue ArgumentError => e
      raise "#{e.message} in given IP range"
    end
1210717
def _get_addresses(self, address_data, retain_name=False):
        
        if retain_name:
            raise NotImplementedError(
                "Not yet implemented, but will need client-code changes too"
            )

        # We trust than an email address contains an "@" after
        # email.utils.getaddresses has done the hard work. If we wanted
        # to we could use a regex to check for greater email validity

        # NB: getaddresses expects a list, so ensure we feed it appropriately
        if isinstance(address_data, str):
            if "[" not in address_data:
                # Definitely turn these into a list
                # NB: this is pretty assumptive, but still prob OK
                address_data = [address_data]

        output = [x[1] for x in getaddresses(address_data) if "@" in x[1]]
        return output