Whitelist *what*.

    :param what: What to whitelist.
    :type what: :class:`list` of :class:`type` or :class:`attr.Attribute`\\ s

    :rtype: :class:`callable`
514290
def include(*what):
    
    cls, attrs = _split_what(what)

    def include_(attribute, value):
        return value.__class__ in cls or attribute in attrs

    return include_
1235862
public SqlBuilder select(final String what) {
    if (null == what) {
      this.select = null;
    } else {
      if (Strings.contains(what.toLowerCase(), "select")) {
        this.select = what;
      } else {
        this.select = "select " + what;
      }
    }
    return this;
  }
581126
public final void mWHICH() throws RecognitionException {
		try {
			int _type = WHICH;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// druidG.g:620:7: ( ( 'WHICH' ) )
			// druidG.g:620:9: ( 'WHICH' )
			{
			// druidG.g:620:9: ( 'WHICH' )
			// druidG.g:620:10: 'WHICH'
			{
			match("WHICH"); 

			}

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
1041224
def query_info(self, what):
        
        if not isinstance(what, baseinteger):
            raise TypeError("what can only be an instance of type baseinteger")
        result = self._call("queryInfo",
                     in_p=[what])
        return result
1240827
def fromRawEntry(cls, **kwargs):
        
        id = kwargs["id"]

        kwargs.pop("id")

        what = cls(**kwargs)
        what._new = False
        what.id = id

        return what
449473
def _is_whitelisted(self, email):
        """"""

        return hasattr(settings, "SAFE_EMAIL_WHITELIST") and \
            any(re.match(m, email) for m in settings.SAFE_EMAIL_WHITELIST)
483830
def makeForwardingMetaclass(forwarding_dest_getter, whitelist, base_class=object):
    
    class ForwardingMetaclass(base_class.__class__):
        def __init__(metaself, name, bases, dct):
            # print('ForwardingMetaclass.__init__():
            #  {forwarding_dest_getter: %r; whitelist: %r}' % (forwarding_dest_getter, whitelist))
            super(ForwardingMetaclass, metaself).__init__(name, bases, dct)
            old_getattr = metaself.__getattribute__
            old_setattr = metaself.__setattr__
            def new_getattr(self, item):
                if item in whitelist:
                    #dest = old_getattr(self, forwarding_dest_name)
                    dest = forwarding_dest_getter(self)
                    try:
                        val = dest.__class__.__getattribute__(dest, item)
                    except AttributeError:
                        val = getattr(dest, item)
                else:
                    val = old_getattr(self, item)
                return val
            def new_setattr(self, name, val):
                if name in whitelist:
                    #dest = old_getattr(self, forwarding_dest_name)
                    dest = forwarding_dest_getter(self)
                    dest.__class__.__setattr__(dest, name, val)
                else:
                    old_setattr(self, name, val)
            metaself.__getattribute__ = new_getattr
            metaself.__setattr__ = new_setattr
    return ForwardingMetaclass
1117495
def get(which):
    ""
    if isinstance(which, str):
        pattern = ('H|      %6s' % which).encode('ascii')
        for star in load(lambda line: line.startswith(pattern)):
            return star
    else:
        patterns = set(id.encode('ascii').rjust(6) for id in which)
        return list(load(lambda line: line[8:14] in patterns))
454177
public function setAsKey($what)
    {
        switch ($what) {
            case self::CLASS_AS_KEY:
            case self::OFFSET_AS_KEY:
                $this->keytype = $what;
                break;
            default:
                $this->keytype = self::CLASS_AS_KEY;
                break;
        }
    }
516505
protected function isContain($what, $where)
    {
        if (empty($what)) {
            return true;
        }

        if (empty($where)) {
            return false;
        }

        if (strpos((string) $where, (string) $what) !== false) {
            return true;
        }

        return false;
    }
21910
def handle_has_members(self, _, __, tokens: ParseResults) -> ParseResults:
        """"""
        return self._handle_list_helper(tokens, HAS_MEMBER)
33802
def parse(self, what):
        
        if '/' not in what:
            key, spec = what, ''
        else:
            key, spec = what.split('/')
        if spec and not spec.startswith(('ref-', 'sid-')):
            raise ValueError('Wrong specification in %s' % what)
        elif spec == '':  # export losses for all assets
            aids = []
            arefs = []
            for aid, rec in enumerate(self.assetcol.array):
                aids.append(aid)
                arefs.append(self.asset_refs[aid])
        elif spec.startswith('sid-'):  # passed the site ID
            sid = int(spec[4:])
            aids = []
            arefs = []
            for aid, rec in enumerate(self.assetcol.array):
                if rec['site_id'] == sid:
                    aids.append(aid)
                    arefs.append(self.asset_refs[aid])
        elif spec.startswith('ref-'):  # passed the asset name
            arefs = [spec[4:]]
            aids = [self.str2asset[arefs[0]]['ordinal']]
        else:
            raise ValueError('Wrong specification in %s' % what)
        return aids, arefs, spec, key
1011174
def should_send(self, request):
        """"""
        if self.filters.get('whitelist', None):
            return request.tree.type in self.filters['whitelist']
        elif self.filters.get('blacklist', None):
            return request.tree.type not in self.filters['blacklist']
        else:
            return True
819840
def callable_validator(v: Any) -> AnyCallable:
    
    if callable(v):
        return v

    raise errors.CallableError(value=v)
580895
def can?(action, subject, *extra_args)
      while subject.is_a?(Draper::Decorator)
        subject = subject.model
      end

      super(action, subject, *extra_args)
    end
1142448
def is_whitelisted(self, addrinfo):
        
        # For details about the ``getaddrinfo`` struct, see the Python docs:
        # http://docs.python.org/library/socket.html#socket.getaddrinfo
        family, socktype, proto, canonname, sockaddr = addrinfo
        address, port = sockaddr[:2]
        return address in self.socket_address_whitelist
56073
def _where(self, filter_fn):
        '''  '''
        assert callable(filter_fn), 'filter_fn needs to be callable'
        return VList(i for i in self if filter_fn(i()))