Returns list of state-fluent CPFs.
166732
def state_cpfs(self) -> List[CPF]:
        ''''''
        _, cpfs = self.cpfs
        state_cpfs = []
        for cpf in cpfs:
            name = utils.rename_next_state_fluent(cpf.name)
            if name in self.state_fluents:
                state_cpfs.append(cpf)
        state_cpfs = sorted(state_cpfs, key=lambda cpf: cpf.name)
        return state_cpfs
450183
def interm_fluent_ordering(self) -> List[str]:
        '''
        '''
        interm_fluents = self.intermediate_fluents.values()
        key = lambda pvar: (pvar.level, pvar.name)
        return [str(pvar) for pvar in sorted(interm_fluents, key=key)]
252635
def get_flags():
    
    flags = unitdata.kv().getrange('reactive.states.', strip=True) or {}
    return sorted(flags.keys())
870673
@Override
	public List<CPDefinition> findAll() {
		return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
	}
604328
def intermediate_fluents(self) -> Dict[str, PVariable]:
        ''''''
        return { str(pvar): pvar for pvar in self.pvariables if pvar.is_intermediate_fluent() }
981314
def state_names():
  
  
  names = set()
  fname = pkg_resources.resource_filename(__name__, 'resources/States.csv')
  with open(fname, 'rU') as csvfile:
    reader = csv.reader(csvfile, delimiter = ',')
    for row in reader:
      names.add(row[0])
  return names
101873
async def get_states_list(self) -> typing.List[typing.Tuple[int]]:
        
        conn = await self.redis()
        result = []

        keys = await conn.keys(self.generate_key('*', '*', STATE_KEY), encoding='utf8')
        for item in keys:
            *_, chat, user, _ = item.split(':')
            result.append((chat, user))

        return result
886303
def intermediate_cpfs(self) -> List[CPF]:
        ''''''
        _, cpfs = self.cpfs
        interm_cpfs = [cpf for cpf in cpfs if cpf.name in self.intermediate_fluents]
        interm_cpfs = sorted(interm_cpfs, key=lambda cpf: (self.intermediate_fluents[cpf.name].level, cpf.name))
        return interm_cpfs
1154402
def initial_state(self) -> StateTensor:
        ''''''
        s0 = []
        for fluent in self._compiler.compile_initial_state(self._batch_size):
            s0.append(self._output_size(fluent))
        s0 = tuple(s0)
        return s0
948294
def state_invariant_scope(self, state: Sequence[tf.Tensor]):
        '''
        '''
        scope = {}
        scope.update(self.non_fluents_scope())
        scope.update(self.state_scope(state))
        return scope
1062317
def decls(self) -> List[z3.ExprRef]:
        """"""
        result = []  # type: List[z3.ExprRef]
        for internal_model in self.raw:
            result.extend(internal_model.decls())
        return result
662895
def _setup_states(state_definitions, prev=()):
    """"""
    states = list(prev)
    for state_def in state_definitions:
        if len(state_def) != 2:
            raise TypeError(
                "The 'state' attribute of a workflow should be "
                "a two-tuple of strings; got %r instead." % (state_def,)
            )
        name, title = state_def
        state = State(name, title)
        if any(st.name == name for st in states):
            # Replacing an existing state
            states = [state if st.name == name else st for st in states]
        else:
            states.append(state)
    return StateList(states)
31731
def state_scope(self, state_fluents: Sequence[tf.Tensor]) -> Dict[str, TensorFluent]:
        '''
        '''
        return dict(zip(self.rddl.domain.state_fluent_ordering, state_fluents))
170573
def get_state(self, **kwargs):
        ""
        state = {'x_cls':self.x.__class__, 'x_proc':self.x.processor,
                 'y_cls':self.y.__class__, 'y_proc':self.y.processor,
                 'tfms':self.tfms, 'tfm_y':self.tfm_y, 'tfmargs':self.tfmargs}
        if hasattr(self, 'tfms_y'):    state['tfms_y']    = self.tfms_y
        if hasattr(self, 'tfmargs_y'): state['tfmargs_y'] = self.tfmargs_y
        return {**state, **kwargs}
1031603
function(fs) {
        var fR = [];
        for (var key in fs) {
            var fact = fs[key];
            if(!fact.explicit) {
                fR.push(fact);
            }
        }
        return fR;
    }
929726
def I(self):
        

        """
        return list(set(range(self.nstates)) - set(self._A) - set(self._B))
197180
def get_implicit_deps(self):
        """"""
        result = []
        build_env = self.get_build_env()
        for act in self.get_action_list():
            deps = act.get_implicit_deps(self.get_all_targets(),
                                         self.get_all_sources(),
                                         build_env)
            result.extend(deps)
        return result