(self, stash_splitter=None, stash_ranker=None, state_ranker=None,
              limit=8, from_stash='active', to_stash='stashed')
return self
Split a stash of states into two stashes depending on the specified options.

        The stash from_stash will be split into two stashes depending on the other options
        passed in. If to_stash is provided, the second stash will be written there.

        stash_splitter overrides stash_ranker, which in turn overrides state_ranker.
        If no functions are provided, the states are simply split according to the limit.

        The sort done with state_ranker is ascending.

        :param stash_splitter:  A function that should take a list of states and return a tuple
                                of two lists (the two resulting stashes).
        :param stash_ranker:    A function that should take a list of states and return a sorted
                                list of states. This list will then be split according to "limit".
        :param state_ranker:    An alternative to stash_splitter. States will be sorted with outputs
                                of this function, which are to be used as a key. The first "limit"
                                of them will be kept, the rest split off.
        :param limit:           For use with state_ranker. The number of states to keep. Default: 8
        :param from_stash:      The stash to split (default: 'active')
        :param to_stash:        The stash to write to (default: 'stashed')

        :returns:               The simulation manager, for chaining.
        :rtype:                 SimulationManager
Split a stash of states into two stashes depending on the specified options.
Split a stash of states into two stashes depending on the specified options .
def split(self, stash_splitter=None, stash_ranker=None, state_ranker=None,
              limit=8, from_stash='active', to_stash='stashed'):
        """
        Split a stash of states into two stashes depending on the specified options.

        The stash from_stash will be split into two stashes depending on the other options
        passed in. If to_stash is provided, the second stash will be written there.

        stash_splitter overrides stash_ranker, which in turn overrides state_ranker.
        If no functions are provided, the states are simply split according to the limit.

        The sort done with state_ranker is ascending.

        :param stash_splitter:  A function that should take a list of states and return a tuple
                                of two lists (the two resulting stashes).
        :param stash_ranker:    A function that should take a list of states and return a sorted
                                list of states. This list will then be split according to "limit".
        :param state_ranker:    An alternative to stash_splitter. States will be sorted with outputs
                                of this function, which are to be used as a key. The first "limit"
                                of them will be kept, the rest split off.
        :param limit:           For use with state_ranker. The number of states to keep. Default: 8
        :param from_stash:      The stash to split (default: 'active')
        :param to_stash:        The stash to write to (default: 'stashed')

        :returns:               The simulation manager, for chaining.
        :rtype:                 SimulationManager
        """
        states = self._fetch_states(stash=from_stash)

        if stash_splitter is not None:
            keep, split = stash_splitter(states)
        elif stash_ranker is not None:
            ranked_paths = stash_ranker(states)
            keep, split = ranked_paths[:limit], ranked_paths[limit:]
        elif state_ranker is not None:
            ranked_paths = sorted(states, key=state_ranker)
            keep, split = ranked_paths[:limit], ranked_paths[limit:]
        else:
            keep, split = states[:limit], states[limit:]

        keep, split = map(list, (keep, split))

        self._clear_states(from_stash)
        self._store_states(from_stash, keep)
        self._store_states(to_stash, split)
        return self
def split ( self , stash_splitter = None , stash_ranker = None , state_ranker = None , limit = 8 , from_stash = 'active' , to_stash = 'stashed' ) : states = self . _fetch_states ( stash = from_stash ) if stash_splitter is not None : keep , split = stash_splitter ( states ) elif stash_ranker is not None : ranked_paths = stash_ranker ( states ) keep , split = ranked_paths [ : limit ] , ranked_paths [ limit : ] elif state_ranker is not None : ranked_paths = sorted ( states , key = state_ranker ) keep , split = ranked_paths [ : limit ] , ranked_paths [ limit : ] else : keep , split = states [ : limit ] , states [ limit : ] keep , split = map ( list , ( keep , split ) ) self . _clear_states ( from_stash ) self . _store_states ( from_stash , keep ) self . _store_states ( to_stash , split ) return self