This function returns the subsystems which have previously been initialized.

    Returns:
        Set[InitFlag]: Flags indicating which subsystems have been initialized.
509925
def was_init():
    
    mask = lib.SDL_WasInit(0)
    return enumtools.get_items(InitFlags, mask, {InitFlags.everything})
350481
def read_init_status(self):
        
        api_path = '/v1/sys/init'
        response = self._adapter.get(
            url=api_path,
        )
        return response.json()
23668
def get_state(cls, clz):
        
        if clz not in cls.__shared_state:
            cls.__shared_state[clz] = (
                clz.init_state() if hasattr(clz, "init_state") else {}
            )
        return cls.__shared_state[clz]
280613
def reset_flags(self):
        
        self.C = None
        self.Z = None
        self.P = None
        self.S = None
973876
def _init_sys_auto_lookup(self):
        
        # TODO: Instead, check for executables for systemd and upstart
        # systemctl for systemd and initctl for upstart.
        # An alternative might be to check the second answer here:
        # http://unix.stackexchange.com/questions/196166/how-to-find-out-if-a-system-uses-sysv-upstart-or-systemd-initsystem
        # TODO: Move to each system's implementation
        init_systems = []
        if self._is_init_system_installed('/usr/lib/systemd'):
            init_systems.append('systemd')
        if self._is_init_system_installed('/usr/share/upstart'):
            init_systems.append('upstart')
        if self._is_init_system_installed('/etc/init.d'):
            init_systems.append('sysv')
        return init_systems
1306640
def getflags(fd):
    

    flags_ptr = ffi.new('uint64_t*')
    flags_buf = ffi.buffer(flags_ptr)
    fcntl.ioctl(fd, lib.FS_IOC_GETFLAGS, flags_buf)
    return flags_ptr[0]
1339887
def _find_uninitialized(self):
    
    return set(name
               for name, prop in self._properties.iteritems()
               if not prop._is_initialized(self))
1204956
def _initialize_initial_state_fluents(self):
        ''''''
        state_fluents = self.rddl.domain.state_fluents
        initializer = self.rddl.instance.init_state
        self.initial_state_fluents = self._initialize_pvariables(
            state_fluents,
            self.rddl.domain.state_fluent_ordering,
            initializer)
        return self.initial_state_fluents
1118178
def reset ():
    
    global __had_unspecified_value, __had_value, __declared_subfeature
    global __init_loc
    global __all_signatures, __debug_configuration, __show_configuration

    # Stores toolsets without specified initialization values.
    __had_unspecified_value = {}

    # Stores toolsets with specified initialization values.
    __had_value = {}

    # Stores toolsets with declared subfeatures.
    __declared_subfeature = {}

    # Stores all signatures of the toolsets.
    __all_signatures = {}

    # Stores the initialization locations of each toolset
    __init_loc = {}

    __debug_configuration = '--debug-configuration' in bjam.variable('ARGV')
    __show_configuration = '--show-configuration' in bjam.variable('ARGV')

    global __executable_path_variable
    OS = bjam.call("peek", [], "OS")[0]
    if OS == "NT":
        # On Windows the case and capitalization of PATH is not always predictable, so
        # let's find out what variable name was really set.
        for n in os.environ:
            if n.lower() == "path":
                __executable_path_variable = n
                break
    else:
        __executable_path_variable = "PATH"

    m = {"NT": __executable_path_variable,
         "CYGWIN": "PATH",
         "MACOSX": "DYLD_LIBRARY_PATH",
         "AIX": "LIBPATH",
         "HAIKU": "LIBRARY_PATH"}
    global __shared_library_path_variable
    __shared_library_path_variable = m.get(OS, "LD_LIBRARY_PATH")
1179878
async def init(self):
        
        self.fsm = FSM()

        checks = []

        # noinspection PyTypeChecker
        async for check in self.run_checks():
            checks.append(check)
            logger.error('HEALTH CHECK FAIL #%s: %s', check.code, check.reason)

        if checks:
            exit(1)

        await self.fsm.async_init()

        self.platforms = {}
67389
def get_missing_flags(conf, atom, flags):
    '''
    
    '''
    new_flags = []
    for flag in flags:
        if not has_flag(conf, atom, flag):
            new_flags.append(flag)
    return new_flags
897243
def init(self, initial):
        
        if initial <= 0:
            return False
        step = initial // BLOCK_SIZE
        with self._lock:
            init = self._atomic_long.compare_and_set(0, step + 1).result()
            if init:
                self._local = step
                self._residue = (initial % BLOCK_SIZE) + 1
            return init
1134733
def system(self):
        
        self.connection._check_login()
        response = self.connection._do_get("{}/{}".format(self.connection._api_url, "types/System/instances")).json()
        all_system_objects = []
        for system_object in response:
            all_system_objects.append(SIO_System.from_dict(system_object))
        return all_system_objects
973936
def get_initial(self):
        
        initial = super(MultiFormView, self).get_initial()
        for key in six.iterkeys(self.form_classes):
            initial[key] = {}
        return initial
795227
def declared_symbols(self):
        

        return self.local_declared_symbols | (
            self.parent.declared_symbols if self.parent else set())
1278499
def getInstitutions(self, tags = None, seperator = ";", _getTag = False):
        
        if tags is None:
            tags = []
        elif isinstance(tags, str):
            tags = [tags]
        for k in self.keys():
            if 'institution' in k.lower() and k not in tags:
                tags.append(k)
        return super().getInvestigators(tags = tags, seperator = seperator, _getTag = _getTag)
1241442
def get_initial_data(self):
        
        data = {}
        ng_models = hasattr(self, 'Meta') and getattr(self.Meta, 'ng_models', []) or []
        for name, field in self.fields.items():
            if 'ng-model' in self.ng_directives or name in ng_models:
                data[name] = self.initial.get(name) if self.initial else field.initial
        return data