Returns state-fluent pvariables.
541220
def state_fluents(self) -> Dict[str, PVariable]:
        ''''''
        return { str(pvar): pvar for pvar in self.pvariables if pvar.is_state_fluent() }
229302
def interm_fluent_variables(self) -> FluentParamsList:
        '''
        '''
        fluents = self.domain.intermediate_fluents
        ordering = self.domain.interm_fluent_ordering
        return self._fluent_params(fluents, ordering)
1371820
def state_dict(self) -> Dict[str, Any]:
        
        return {key: value for key, value in self.__dict__.items() if key != 'optimizer'}
27174
def process_states(instates)
      outstates = {}
      instates.each do |inst|
        name = inst.delete(:name)
        outstates[name] ||= []
        outstates[name] << inst
      end
      return outstates
    end
74425
public LifecycleState getState(Object obj)
    {
        LifecycleStateWrapper lifecycleState = objectStates.get(obj);
        if ( lifecycleState == null )
        {
            return hasStarted() ? LifecycleState.ACTIVE : LifecycleState.LATENT;
        }
        else {
            synchronized(lifecycleState) {
                return lifecycleState.get();
            }
        }
    }
1349046
def GetRunlevelsLSB(states):
  """"""
  if not states:
    return set()
  valid = set(["0", "1", "2", "3", "4", "5", "6"])
  _LogInvalidRunLevels(states, valid)
  return valid.intersection(set(states.split()))
1341811
def states(self):
        """"""
        state_list = []
        for state in States:
            if state.value & self._states != 0:
                state_list.append(state)

        if (self._flashing_states & States.FILTER) != 0:
            state_list.append(States.FILTER_LOW_SPEED)

        return state_list
33074
def luns(self):
        """"""
        lun_list, smp_list = [], []
        if self.ioclass_luns:
            lun_list = map(lambda l: VNXLun(lun_id=l.lun_id, name=l.name,
                                            cli=self._cli), self.ioclass_luns)
        if self.ioclass_snapshots:
            smp_list = map(lambda smp: VNXLun(name=smp.name, cli=self._cli),
                           self.ioclass_snapshots)
        return list(lun_list) + list(smp_list)
1225741
def all_state_variables_written(self):
        '''
            
        '''
        all_state_variables_written = [f.all_state_variables_written() for f in self.functions + self.modifiers]
        all_state_variables_written = [item for sublist in all_state_variables_written for item in sublist]
        return list(set(all_state_variables_written))
42340
def _provider_state_fixtures_with_params(
        provider_state_fixture_by_descriptor: Dict[str, ProviderStateFixture],
        provider_states: Tuple[ProviderState, ...]
) -> List[Tuple[ProviderStateFixture, Dict]]:
    
    provider_state_fixtures_with_params: List[Tuple[ProviderStateFixture, Dict]] = []
    for provider_state in provider_states:
        provider_state_fixture = provider_state_fixture_by_descriptor.get(provider_state.descriptor)
        if not provider_state_fixture:
            raise UnsupportedProviderStateError(
                f'Missing expected provider state: {provider_state}'
            )
        if provider_state.params:
            fixture_params = _pluck_parameter_names(provider_state_fixture)
            if not frozenset(provider_state.params.keys()) == fixture_params:
                raise UnsupportedProviderStateError(
                    'Expected provider state params dont match those of '
                    + f'provider. Expected: {provider_state}. Actual: {fixture_params}.'
                )
        provider_state_fixtures_with_params.append(
            (provider_state_fixture, provider_state.params or {})
        )

    return provider_state_fixtures_with_params
624274
function() {
        if (!this.states) return

        if (!this.states.hasOwnProperty(INIT_STATE))
          this.state(INIT_STATE, {})

        var name, states = this.states
        for (name in states)
          this.state(name, states[name])
      }
1047946
public Set<OIdentifiable> getInEdgesHavingProperties(final ODocument iVertex, final Map<String, Object> iProperties) {
    checkVertexClass(iVertex);
    return filterEdgesByProperties((OMVRBTreeRIDSet) iVertex.field(VERTEX_FIELD_IN), iProperties);
  }
610426
def get_states(self, obj):
        """"""
        return reverse(
            'electionnight_api_state-election-list',
            request=self.context['request'],
            kwargs={'date': obj.date}
        )
1211566
def get_state(self):
        

        self.step_methods = set()
        for s in self.stochastics:
            self.step_methods |= set(self.step_method_dict[s])

        state = Sampler.get_state(self)
        state['step_methods'] = {}

        # The state of each StepMethod.
        for sm in self.step_methods:
            state['step_methods'][sm._id] = sm.current_state().copy()

        return state
6624
def action_fluent_variables(self) -> FluentParamsList:
        '''
        '''
        fluents = self.domain.action_fluents
        ordering = self.domain.action_fluent_ordering
        return self._fluent_params(fluents, ordering)
72043
def _initialize_non_fluents(self):
        ''''''
        non_fluents = self.rddl.domain.non_fluents
        initializer = self.rddl.non_fluents.init_non_fluent
        self.non_fluents = self._initialize_pvariables(
            non_fluents,
            self.rddl.domain.non_fluent_ordering,
            initializer)
        return self.non_fluents
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