Get if current node shouldn't be shown, using :attt:`app` config's
        exclude_fnc.

        :returns: True if excluded, False otherwise
556238
def is_excluded(self):
        '''
        
        '''
        exclude = self.app and self.app.config['exclude_fnc']
        return exclude and exclude(self.path)
807363
def hide_restricted(self, ):
        
        tohide = [((self.reftrack.unload, self.unload_tb),
                   (self.reftrack.load, self.load_tb)),
                  ((self.reftrack.import_file, self.importtf_tb),
                   (self.reftrack.import_reference, self.importref_tb))]
        for (action1, btn1), (action2, btn2) in tohide:
            res1 = self.reftrack.is_restricted(action1)
            res2 = self.reftrack.is_restricted(action2)
            if res1 != res2:
                btn1.setEnabled(True)
                btn1.setHidden(res1)
                btn2.setHidden(res2)
            else:  # both are restricted, then show one but disable it
                btn1.setDisabled(True)
                btn1.setVisible(True)
                btn2.setVisible(False)
867393
def check_include_exclude(attributes):
        
        include = attributes.get('__include__', tuple())
        exclude = attributes.get('__exclude__', tuple())

        if not isinstance(include, tuple):
            raise TypeError("Attribute __include__ must be a tuple.")

        if not isinstance(exclude, tuple):
            raise TypeError("Attribute __exclude__ must be a tuple.")

        if all((not include, not exclude)):
            return None

        if all((include, exclude)):
            raise AttributeError("Usage of __include__ and __exclude__ "
                                 "at the same time is prohibited.")
397855
function isExcludedFromBuild(node) {
	if (node.load.excludeFromBuild) {
		return true;
	}

	if (
		node.load.metadata &&
		node.load.metadata.hasOwnProperty("bundle") &&
		node.load.metadata.bundle === false
	) {
		return true;
	}

	if (
		node.isPlugin &&
		!node.value.includeInBuild &&
		!node.load.metadata.includeInBuild
	) {
		return true;
	}

	return false;
}
305036
def node_mustNotInclude(self, al_mustNotInclude, ab_reset=False):
            
            if ab_reset:
                self.snode_current.l_mustNotInclude = al_mustNotInclude[:]
            else:
                l_current   = self.snode_current.l_mustNotInclude[:]
                l_total     = l_current + al_mustNotInclude
                self.snode_current.l_mustNotInclude = l_total[:]
436241
def in6_isincluded(addr, prefix, plen):
    
    temp = inet_pton(socket.AF_INET6, addr)
    pref = in6_cidr2mask(plen)
    zero = inet_pton(socket.AF_INET6, prefix)
    return zero == in6_and(temp, pref)
803315
def ignore_cec(self):
        
        return self.device is not None and \
            any([fnmatch.fnmatchcase(self.device.friendly_name, pattern)
                 for pattern in IGNORE_CEC])
1308976
def is_file_excluded(filename, excludes):
    
    # check if you need to exclude this file
    return any([exclude and re.match(exclude, filename) is not None
                for exclude in excludes])
458965
def _is_exempt(self, environ):
        
        exemptions = self.exclude_paths

        if exemptions:
            path = environ.get('PATH_INFO')
            for excluded_p in self.exclude_paths:
                if path.startswith(excluded_p):
                    return True

        return False
1219441
def _is_excluded(self, path, dir_only):
        """"""

        return self.npatterns and self._match_excluded(path, self.npatterns)
177493
def _is_exposed(minion):
    '''
    
    '''
    return salt.utils.stringutils.check_whitelist_blacklist(
        minion,
        whitelist=__opts__['minionfs_whitelist'],
        blacklist=__opts__['minionfs_blacklist']
    )
488576
def is_hide(self, value, header=""):
        
        # TODO: possible optimisation: create a re.compile list
        return not all(j is None for j in [re.match(i, value.lower()) for i in self.get_conf_value('hide', header=header)])
1266290
def excluded(filename):
    
    basename = os.path.basename(filename)
    for pattern in options.exclude:
        if fnmatch(basename, pattern):
            # print basename, 'excluded because it matches', pattern
            return True
193917
private boolean isVisibleInBackend(AccessControllable node) {

		if (isVisibleInFrontend(node)) {

			return true;

		}

		// no node, nothing to see here..
		if (node == null) {

			return false;
		}

		// fetch user
		final Principal user = getUser(false);

		// anonymous users may not see any nodes in backend
		if (user == null) {

			return false;
		}

		// SuperUser may always see the node
		if (user instanceof SuperUser) {

			return true;
		}

		return node.isGranted(Permission.read, this);
	}
1072511
private static boolean hasText(AccessibilityNodeInfoCompat node) {
        if (node == null) {
            return false;
        }

        return (!TextUtils.isEmpty(node.getText())
                || !TextUtils.isEmpty(node.getContentDescription()));
    }
1339273
def _should_ignore(self, path):
        
        for ignore in self.options.ignores:
            if fnmatch.fnmatch(path, ignore):
                return True
        return False
209750
def isLocked( self ):
        
        # return if the layer is not the current layer
        if self._layer and not self._layer.isCurrent():
             return True
        
        # return whether or not the node is enabld or locked
        return not self._enabled or (self._xLocked and self._yLocked)