Returns ``True`` if any of ``instances`` match an active switch. Otherwise
        returns ``False``.

        >>> gargoyle.is_active('my_feature', request) #doctest: +SKIP
6356
def is_active(self, key, *instances, **kwargs):
        
        default = kwargs.pop('default', False)

        # Check all parents for a disabled state
        parts = key.split(':')
        if len(parts) > 1:
            child_kwargs = kwargs.copy()
            child_kwargs['default'] = None
            result = self.is_active(':'.join(parts[:-1]), *instances, **child_kwargs)

            if result is False:
                return result
            elif result is True:
                default = result

        try:
            switch = self[key]
        except KeyError:
            # switch is not defined, defer to parent
            return default

        if switch.status == GLOBAL:
            return True
        elif switch.status == DISABLED:
            return False
        elif switch.status == INHERIT:
            return default

        conditions = switch.value
        # If no conditions are set, we inherit from parents
        if not conditions:
            return default

        if instances:
            # HACK: support request.user by swapping in User instance
            instances = list(instances)
            for v in instances:
                if isinstance(v, HttpRequest) and hasattr(v, 'user'):
                    instances.append(v.user)

        # check each switch to see if it can execute
        return_value = False

        for switch in self._registry.itervalues():
            result = switch.has_active_condition(conditions, instances)
            if result is False:
                return False
            elif result is True:
                return_value = True

        # there were no matching conditions, so it must not be enabled
        return return_value
540370
def is_active(self, path):
        """"""
        if self.url == '/' and self.url == path:
            return True
        elif self.url == '/':
            return False

        if self.url and path.startswith(self.url):
            return True

        if self.active_regex and re.compile(self.active_regex).match(path):
            return True

        for child in self.childs:
            if child.is_active(path):
                return True
        return False
1299929
def is_active(self, timeout=2):
        
        try:
            result = Result(*self.perform_request('HEAD', '/', params={'request_timeout': timeout}))
        except ConnectionError:
            return False
        except TransportError:
            return False

        if result.response.status_code == 200:
            return True

        return False
1098096
def is_active(self):
        """"""
        if self._queue.exhausted:
            return False
        return any(ch.is_active for ch in self._refs.values())
253729
def is_active(self):
    
    return bool(
        self._grpc_port is not None and
        self._event_multiplexer and
        self._event_multiplexer.PluginRunToTagToContent(
            constants.DEBUGGER_PLUGIN_NAME))
278087
def is_instance_running(self, instance_id):
        
        items = self.list_instances(filter=('name eq "%s"' % instance_id))
        for item in items:
            if item['status'] == 'RUNNING':
                return True
        return False
1052026
def exists(self):
        
        return self.rpc_model.search_count(
            self.domain, context=self.context
        ) > 0
1153667
def is_active(self, instance, conditions):
        
        if isinstance(instance, User):
            return super(UserConditionSet, self).is_active(instance, conditions)

        # HACK: allow is_authenticated to work on AnonymousUser
        condition = conditions.get(self.get_namespace(), {}).get('is_anonymous')
        if condition is not None:
            return bool(condition)
        return None
644646
def has_instance(name, provider=None):
    '''
    
    '''
    data = get_instance(name, provider)
    if data is None:
        return False
    return True
399533
def active(self):
        
        return {key: value for key, value in self.conns.items()
                if value.active}
272838
def is_any_clicked(self):
        """"""
        for key in range(len(self.current_state.key_states)):
            if self.is_clicked(key):
                return True
        return False
1231615
def alive(self):
        ''''''
        with self._mutex:
            if self.exec_contexts:
                for ec in self.exec_contexts:
                    if self._obj.is_alive(ec):
                        return True
        return False
1374762
def active(self):
        
        qset = super(StaffMemberManager, self).get_queryset()
        return qset.filter(is_active=True)
822060
def get_default_is_active():
    
    directory = APPLICATION.default_account_store_mapping.account_store
    verif_email = directory.account_creation_policy.verification_email_status
    return verif_email == AccountCreationPolicy.EMAIL_STATUS_DISABLED
411122
function isActive(vertex, instance) {
    return vertex.parent ? isActive(vertex.parent.parent, instance) && instance.getLastKnownState(vertex.parent) === vertex : true;
}
379533
def active(self):
        
        result = 0
        for actor in self.actors:
            if not actor.skip:
                result += 1
        return result
751238
def is_switched_on(self, refresh=False):
        
        if refresh:
            self.refresh()
        return self.get_brightness(refresh) > 0